From 6612d0731fc230befeb800bd8018e008ec4030c8 Mon Sep 17 00:00:00 2001 From: Sky Johnson Date: Wed, 2 Jul 2025 13:14:42 -0500 Subject: [PATCH] forgot to commit lol --- cmd/loginServer/clients.go | 90 + cmd/loginServer/config.go | 86 + cmd/loginServer/database.go | 201 ++ cmd/loginServer/main.go | 267 ++ cmd/loginServer/opcodes.go | 143 ++ cmd/loginServer/tcp.go | 300 +++ cmd/loginServer/web.go | 263 ++ cmd/loginServer/worlds.go | 103 + go.mod | 29 + go.sum | 47 + internal/opcodes/game.go | 469 ++++ internal/opcodes/login.go | 43 + internal/opcodes/protocol.go | 19 + internal/opcodes/server.go | 111 + internal/opcodes/utils.go | 67 + source/LoginServer/EQ2 Login.sln | 25 - source/LoginServer/EQ2 Login.suo | Bin 58880 -> 0 bytes source/LoginServer/Login.dsp | 447 ---- source/LoginServer/Login.dsw | 29 - source/LoginServer/Login.vcproj | 542 ---- source/LoginServer/Login.vcxproj | 154 -- source/LoginServer/Login.vcxproj.filters | 277 -- source/LoginServer/Login.vcxproj.user | 3 - source/LoginServer/Web/LoginWeb.o | Bin 5302112 -> 0 bytes source/LoginServer/makefile | 32 - source/common/CRC16.cpp | 328 --- source/common/CRC16.h | 25 - source/common/Common_Defines.h | 32 - source/common/Condition.cpp | 133 - source/common/Condition.h | 48 - source/common/Crypto.cpp | 47 - source/common/Crypto.h | 66 - source/common/DataBuffer.h | 207 -- source/common/DatabaseNew.cpp | 422 --- source/common/DatabaseNew.h | 48 - source/common/DatabaseResult.cpp | 234 -- source/common/DatabaseResult.h | 57 - source/common/JsonParser.cpp | 97 - source/common/JsonParser.h | 33 - source/common/Mutex.cpp | 361 --- source/common/Mutex.h | 103 - source/common/RC4.cpp | 93 - source/common/RC4.h | 38 - source/common/TCPConnection.cpp | 1729 ------------- source/common/TCPConnection.h | 277 -- source/common/database.cpp | 567 ----- source/common/database.h | 183 -- source/common/dbcore.cpp | 368 --- source/common/dbcore.h | 80 - source/common/debug.cpp | 336 --- source/common/debug.h | 143 -- source/common/linked_list.h | 445 ---- source/common/md5.cpp | 281 -- source/common/md5.h | 64 - source/common/queue.h | 128 - source/common/sha512.cpp | 155 -- source/common/sha512.h | 71 - source/common/string_util.cpp | 529 ---- source/common/string_util.h | 193 -- source/common/timer.cpp | 207 -- source/common/timer.h | 88 - source/common/unix.cpp | 45 - source/common/unix.h | 34 - source/common/xmlParser.cpp | 2974 ---------------------- source/common/xmlParser.h | 732 ------ 65 files changed, 2238 insertions(+), 13510 deletions(-) create mode 100644 cmd/loginServer/clients.go create mode 100644 cmd/loginServer/config.go create mode 100644 cmd/loginServer/database.go create mode 100644 cmd/loginServer/main.go create mode 100644 cmd/loginServer/opcodes.go create mode 100644 cmd/loginServer/tcp.go create mode 100644 cmd/loginServer/web.go create mode 100644 cmd/loginServer/worlds.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/opcodes/game.go create mode 100644 internal/opcodes/login.go create mode 100644 internal/opcodes/protocol.go create mode 100644 internal/opcodes/server.go create mode 100644 internal/opcodes/utils.go delete mode 100644 source/LoginServer/EQ2 Login.sln delete mode 100644 source/LoginServer/EQ2 Login.suo delete mode 100644 source/LoginServer/Login.dsp delete mode 100644 source/LoginServer/Login.dsw delete mode 100644 source/LoginServer/Login.vcproj delete mode 100644 source/LoginServer/Login.vcxproj delete mode 100644 source/LoginServer/Login.vcxproj.filters delete mode 100644 source/LoginServer/Login.vcxproj.user delete mode 100644 source/LoginServer/Web/LoginWeb.o delete mode 100644 source/LoginServer/makefile delete mode 100644 source/common/CRC16.cpp delete mode 100644 source/common/CRC16.h delete mode 100644 source/common/Common_Defines.h delete mode 100644 source/common/Condition.cpp delete mode 100644 source/common/Condition.h delete mode 100644 source/common/Crypto.cpp delete mode 100644 source/common/Crypto.h delete mode 100644 source/common/DataBuffer.h delete mode 100644 source/common/DatabaseNew.cpp delete mode 100644 source/common/DatabaseNew.h delete mode 100644 source/common/DatabaseResult.cpp delete mode 100644 source/common/DatabaseResult.h delete mode 100644 source/common/JsonParser.cpp delete mode 100644 source/common/JsonParser.h delete mode 100644 source/common/Mutex.cpp delete mode 100644 source/common/Mutex.h delete mode 100644 source/common/RC4.cpp delete mode 100644 source/common/RC4.h delete mode 100644 source/common/TCPConnection.cpp delete mode 100644 source/common/TCPConnection.h delete mode 100644 source/common/database.cpp delete mode 100644 source/common/database.h delete mode 100644 source/common/dbcore.cpp delete mode 100644 source/common/dbcore.h delete mode 100644 source/common/debug.cpp delete mode 100644 source/common/debug.h delete mode 100644 source/common/linked_list.h delete mode 100644 source/common/md5.cpp delete mode 100644 source/common/md5.h delete mode 100644 source/common/queue.h delete mode 100644 source/common/sha512.cpp delete mode 100644 source/common/sha512.h delete mode 100644 source/common/string_util.cpp delete mode 100644 source/common/string_util.h delete mode 100644 source/common/timer.cpp delete mode 100644 source/common/timer.h delete mode 100644 source/common/unix.cpp delete mode 100644 source/common/unix.h delete mode 100644 source/common/xmlParser.cpp delete mode 100644 source/common/xmlParser.h diff --git a/cmd/loginServer/clients.go b/cmd/loginServer/clients.go new file mode 100644 index 0000000..c6a903f --- /dev/null +++ b/cmd/loginServer/clients.go @@ -0,0 +1,90 @@ +package main + +import ( + "sync" + "time" + + "github.com/panjf2000/gnet/v2" + "zombiezen.com/go/sqlite/sqlitex" +) + +type ClientState int + +const ( + StateConnected ClientState = iota + StateAuthenticated + StateCharacterSelect + StateDisconnected +) + +type Client struct { + conn gnet.Conn + address string + connected time.Time + lastActive time.Time + state ClientState + accountID uint32 + accountName string + version int16 + mu sync.RWMutex +} + +type ClientManager struct { + clients map[int]*Client + db *sqlitex.Pool + mu sync.RWMutex +} + +func NewClientManager(db *sqlitex.Pool) *ClientManager { + return &ClientManager{ + clients: make(map[int]*Client), + db: db, + } +} + +func (cm *ClientManager) AddClient(fd int, client *Client) { + cm.mu.Lock() + defer cm.mu.Unlock() + cm.clients[fd] = client +} + +func (cm *ClientManager) RemoveClient(fd int) { + cm.mu.Lock() + defer cm.mu.Unlock() + delete(cm.clients, fd) +} + +func (cm *ClientManager) GetClient(fd int) *Client { + cm.mu.RLock() + defer cm.mu.RUnlock() + return cm.clients[fd] +} + +func (cm *ClientManager) CleanupExpired() { + cm.mu.Lock() + defer cm.mu.Unlock() + + cutoff := time.Now().Add(-30 * time.Minute) + for fd, client := range cm.clients { + if client.lastActive.Before(cutoff) { + client.conn.Close() + delete(cm.clients, fd) + } + } +} + +func (cm *ClientManager) GetStats() (int, int) { + cm.mu.RLock() + defer cm.mu.RUnlock() + + total := len(cm.clients) + authenticated := 0 + + for _, client := range cm.clients { + if client.state == StateAuthenticated { + authenticated++ + } + } + + return total, authenticated +} diff --git a/cmd/loginServer/config.go b/cmd/loginServer/config.go new file mode 100644 index 0000000..2c37e03 --- /dev/null +++ b/cmd/loginServer/config.go @@ -0,0 +1,86 @@ +package main + +import ( + "os" + + "github.com/goccy/go-json" +) + +type Config struct { + Server ServerConfig `json:"server"` + Database DatabaseConfig `json:"database"` + Web WebConfig `json:"web"` + Game GameConfig `json:"game"` +} + +type ServerConfig struct { + Port int `json:"port"` + MaxClients int `json:"max_clients"` + MaxWorldServers int `json:"max_world_servers"` +} + +type DatabaseConfig struct { + Path string `json:"path"` +} + +type WebConfig struct { + Enabled bool `json:"enabled"` + Address string `json:"address"` + Port int `json:"port"` + CertFile string `json:"cert_file"` + KeyFile string `json:"key_file"` + Username string `json:"username"` + Password string `json:"password"` +} + +type GameConfig struct { + AllowAccountCreation bool `json:"allow_account_creation"` + ExpansionFlag uint32 `json:"expansion_flag"` + CitiesFlag uint8 `json:"cities_flag"` + DefaultSubscriptionLevel uint32 `json:"default_subscription_level"` + EnabledRaces uint32 `json:"enabled_races"` + MaxCharactersPerAccount int `json:"max_characters_per_account"` +} + +func LoadConfig(filename string) (*Config, error) { + data, err := os.ReadFile(filename) + if err != nil { + // Return default config if file doesn't exist + return getDefaultConfig(), nil + } + + var config Config + if err := json.Unmarshal(data, &config); err != nil { + return nil, err + } + + return &config, nil +} + +func getDefaultConfig() *Config { + return &Config{ + Server: ServerConfig{ + Port: 5998, + MaxClients: 1000, + MaxWorldServers: 10, + }, + Database: DatabaseConfig{ + Path: "login.db", + }, + Web: WebConfig{ + Enabled: true, + Address: "0.0.0.0", + Port: 8080, + Username: "admin", + Password: "password", + }, + Game: GameConfig{ + AllowAccountCreation: true, + ExpansionFlag: 0x7CFF, + CitiesFlag: 0xFF, + DefaultSubscriptionLevel: 0xFFFFFFFF, + EnabledRaces: 0xFFFF, + MaxCharactersPerAccount: 7, + }, + } +} diff --git a/cmd/loginServer/database.go b/cmd/loginServer/database.go new file mode 100644 index 0000000..3c81315 --- /dev/null +++ b/cmd/loginServer/database.go @@ -0,0 +1,201 @@ +package main + +import ( + "crypto/sha512" + "fmt" + "time" + + "zombiezen.com/go/sqlite" +) + +func authenticateUser(conn *sqlite.Conn, username, password string, allowCreate bool) (bool, uint32, error) { + stmt := conn.Prep("SELECT id, password FROM accounts WHERE name = ?") + stmt.BindText(1, username) + + if hasRow, err := stmt.Step(); err != nil { + return false, 0, err + } else if !hasRow { + if allowCreate { + return createAccount(conn, username, password) + } + return false, 0, nil + } + + accountID := stmt.ColumnInt64(0) + storedPassword := stmt.ColumnText(1) + + if verifyPassword(password, storedPassword) { + return true, uint32(accountID), nil + } + + return false, 0, nil +} + +func createAccount(conn *sqlite.Conn, username, password string) (bool, uint32, error) { + hashedPassword := hashPassword(password) + + stmt := conn.Prep("INSERT INTO accounts (name, password, created_date) VALUES (?, ?, ?)") + stmt.BindText(1, username) + stmt.BindText(2, hashedPassword) + stmt.BindInt64(3, time.Now().Unix()) + + if _, err := stmt.Step(); err != nil { + return false, 0, err + } + + accountID := conn.LastInsertRowID() + return true, uint32(accountID), nil +} + +func hashPassword(password string) string { + hash := sha512.Sum512([]byte(password)) + return fmt.Sprintf("%x", hash) +} + +func verifyPassword(password, stored string) bool { + return hashPassword(password) == stored +} + +func getCharacterList(conn *sqlite.Conn, accountID uint32) ([]*Character, error) { + stmt := conn.Prep(` + SELECT id, name, race, class, gender, level, current_zone_id, + server_id, created_date, last_played + FROM login_characters + WHERE account_id = ? AND deleted = 0 + `) + stmt.BindInt64(1, int64(accountID)) + + var characters []*Character + + for { + hasRow, err := stmt.Step() + if err != nil { + return nil, err + } + if !hasRow { + break + } + + char := &Character{ + ID: uint32(stmt.ColumnInt64(0)), + Name: stmt.ColumnText(1), + Race: uint8(stmt.ColumnInt64(2)), + Class: uint8(stmt.ColumnInt64(3)), + Gender: uint8(stmt.ColumnInt64(4)), + Level: uint8(stmt.ColumnInt64(5)), + Zone: getZoneName(stmt.ColumnInt64(6)), + ServerID: uint32(stmt.ColumnInt64(7)), + Created: stmt.ColumnInt64(8), + LastLogin: stmt.ColumnInt64(9), + } + + characters = append(characters, char) + } + + return characters, nil +} + +func createCharacter(conn *sqlite.Conn, accountID uint32, req *CreateCharacterRequest) (uint32, error) { + // Check if name is taken + stmt := conn.Prep("SELECT id FROM login_characters WHERE name = ? AND deleted = 0") + stmt.BindText(1, req.Name) + + if hasRow, err := stmt.Step(); err != nil { + return 0, err + } else if hasRow { + return 0, fmt.Errorf("name already taken") + } + + // Create character + stmt = conn.Prep(` + INSERT INTO login_characters ( + account_id, server_id, char_id, name, race, class, gender, + deity, body_size, body_age, created_date + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + `) + + stmt.BindInt64(1, int64(accountID)) + stmt.BindInt64(2, int64(req.ServerID)) + stmt.BindInt64(3, generateCharacterID()) + stmt.BindText(4, req.Name) + stmt.BindInt64(5, int64(req.Race)) + stmt.BindInt64(6, int64(req.Class)) + stmt.BindInt64(7, int64(req.Gender)) + stmt.BindInt64(8, int64(req.Deity)) + stmt.BindFloat(9, float64(req.BodySize)) + stmt.BindFloat(10, float64(req.BodyAge)) + stmt.BindInt64(11, time.Now().Unix()) + + if _, err := stmt.Step(); err != nil { + return 0, err + } + + return uint32(conn.LastInsertRowID()), nil +} + +func deleteCharacter(conn *sqlite.Conn, accountID, characterID uint32) error { + stmt := conn.Prep(` + UPDATE login_characters + SET deleted = 1 + WHERE id = ? AND account_id = ? + `) + stmt.BindInt64(1, int64(characterID)) + stmt.BindInt64(2, int64(accountID)) + + _, err := stmt.Step() + return err +} + +func generateCharacterID() int64 { + return time.Now().UnixNano() / 1000000 // Use timestamp as unique ID +} + +func getZoneName(zoneID int64) string { + // Simple zone mapping - in real implementation this would be from database + zones := map[int64]string{ + 1: "Qeynos", + 2: "Freeport", + 3: "Kelethin", + 4: "Neriak", + 5: "Gorowyn", + 6: "New Halas", + 7: "Queen's Colony", + 8: "Outpost of the Overlord", + } + + if name, exists := zones[zoneID]; exists { + return name + } + return "Unknown Zone" +} + +func updateCharacterLastLogin(conn *sqlite.Conn, characterID uint32) error { + stmt := conn.Prep("UPDATE login_characters SET last_played = ? WHERE id = ?") + stmt.BindInt64(1, time.Now().Unix()) + stmt.BindInt64(2, int64(characterID)) + + _, err := stmt.Step() + return err +} + +func getAccountStats(conn *sqlite.Conn) (int, int, error) { + // Total accounts + stmt := conn.Prep("SELECT COUNT(*) FROM accounts") + if hasRow, err := stmt.Step(); err != nil { + return 0, 0, err + } else if !hasRow { + return 0, 0, nil + } + totalAccounts := int(stmt.ColumnInt64(0)) + + // Total characters + stmt = conn.Prep("SELECT COUNT(*) FROM login_characters WHERE deleted = 0") + if hasRow, err := stmt.Step(); err != nil { + return 0, 0, err + } else if !hasRow { + return totalAccounts, 0, nil + } + totalCharacters := int(stmt.ColumnInt64(0)) + + return totalAccounts, totalCharacters, nil +} diff --git a/cmd/loginServer/main.go b/cmd/loginServer/main.go new file mode 100644 index 0000000..2ef5a80 --- /dev/null +++ b/cmd/loginServer/main.go @@ -0,0 +1,267 @@ +package main + +import ( + "context" + "log" + "os" + "os/signal" + "sync" + "syscall" + "time" + + "github.com/panjf2000/gnet/v2" + "github.com/valyala/fasthttp" + "zombiezen.com/go/sqlite" + "zombiezen.com/go/sqlite/sqlitex" +) + +type LoginServer struct { + config *Config + db *sqlitex.Pool + clients *ClientManager + worlds *WorldManager + opcodes map[int16]*OpcodeManager + webServer *fasthttp.Server + ctx context.Context + cancel context.CancelFunc + mu sync.RWMutex + running bool + startTime time.Time +} + +func main() { + server := &LoginServer{ + startTime: time.Now(), + } + + if err := server.initialize(); err != nil { + log.Fatalf("Failed to initialize server: %v", err) + } + + server.printHeader() + + if err := server.start(); err != nil { + log.Fatalf("Failed to start server: %v", err) + } + + // Wait for shutdown signal + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + <-sigCh + + log.Println("Shutting down...") + server.shutdown() +} + +func (s *LoginServer) initialize() error { + s.ctx, s.cancel = context.WithCancel(context.Background()) + + // Load configuration + config, err := LoadConfig("login_config.json") + if err != nil { + return err + } + s.config = config + + // Initialize database + if err := s.initDatabase(); err != nil { + return err + } + + // Initialize managers + s.clients = NewClientManager(s.db) + s.worlds = NewWorldManager(s.db) + + // Load opcodes + if err := s.loadOpcodes(); err != nil { + return err + } + + // Initialize web server + s.initWebServer() + + return nil +} + +func (s *LoginServer) initDatabase() error { + pool, err := sqlitex.Open(s.config.Database.Path, 0, 10) + if err != nil { + return err + } + s.db = pool + + // Create tables + conn := s.db.Get(s.ctx) + defer s.db.Put(conn) + + return s.createTables(conn) +} + +func (s *LoginServer) createTables(conn *sqlite.Conn) error { + schema := ` + CREATE TABLE IF NOT EXISTS accounts ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT UNIQUE NOT NULL, + password TEXT NOT NULL, + created_date INTEGER DEFAULT CURRENT_TIMESTAMP, + ip_address TEXT, + last_client_version INTEGER + ); + + CREATE TABLE IF NOT EXISTS login_characters ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + account_id INTEGER NOT NULL, + server_id INTEGER NOT NULL, + char_id INTEGER NOT NULL, + name TEXT NOT NULL, + race INTEGER NOT NULL, + class INTEGER NOT NULL, + gender INTEGER NOT NULL, + deity INTEGER NOT NULL, + body_size REAL NOT NULL, + body_age REAL NOT NULL, + level INTEGER DEFAULT 1, + current_zone_id INTEGER DEFAULT 1, + created_date INTEGER DEFAULT CURRENT_TIMESTAMP, + last_played INTEGER, + deleted INTEGER DEFAULT 0, + FOREIGN KEY(account_id) REFERENCES accounts(id) + ); + + CREATE TABLE IF NOT EXISTS login_worldservers ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + account TEXT UNIQUE NOT NULL, + name TEXT NOT NULL, + password TEXT NOT NULL, + admin_id INTEGER DEFAULT 0, + disabled INTEGER DEFAULT 0, + ip_address TEXT, + lastseen INTEGER + ); + + CREATE TABLE IF NOT EXISTS login_equipment ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + login_characters_id INTEGER NOT NULL, + equip_type INTEGER NOT NULL, + red INTEGER NOT NULL, + green INTEGER NOT NULL, + blue INTEGER NOT NULL, + highlight_red INTEGER NOT NULL, + highlight_green INTEGER NOT NULL, + highlight_blue INTEGER NOT NULL, + slot INTEGER NOT NULL, + FOREIGN KEY(login_characters_id) REFERENCES login_characters(id) + );` + + return sqlitex.ExecScript(conn, schema) +} + +func (s *LoginServer) loadOpcodes() error { + s.opcodes = make(map[int16]*OpcodeManager) + + // For demo, loading basic opcodes - in real implementation, + // these would be loaded from database + manager := &OpcodeManager{ + opcodes: map[string]uint16{ + "OP_LoginRequestMsg": 0x0001, + "OP_LoginReplyMsg": 0x0002, + "OP_AllWSDescRequestMsg": 0x0003, + "OP_CreateCharacterRequestMsg": 0x0004, + "OP_PlayCharacterRequestMsg": 0x0005, + "OP_DeleteCharacterRequestMsg": 0x0006, + }, + } + + s.opcodes[1208] = manager // Default version + return nil +} + +func (s *LoginServer) initWebServer() { + router := &WebRouter{server: s} + s.webServer = &fasthttp.Server{ + Handler: router.Handler, + Name: "EQ2LoginWeb", + } +} + +func (s *LoginServer) start() error { + s.mu.Lock() + s.running = true + s.mu.Unlock() + + // Start TCP server for game clients + go func() { + tcpServer := &TCPServer{ + server: s, + clients: s.clients, + worlds: s.worlds, + } + + log.Printf("Starting TCP server on port %d", s.config.Server.Port) + if err := gnet.Run(tcpServer, + "tcp://:"+string(rune(s.config.Server.Port)), + gnet.WithMulticore(true), + gnet.WithTCPKeepAlive(time.Minute*5)); err != nil { + log.Printf("TCP server error: %v", err) + } + }() + + // Start web server + if s.config.Web.Enabled { + go func() { + addr := s.config.Web.Address + ":" + string(rune(s.config.Web.Port)) + log.Printf("Starting web server on %s", addr) + if err := s.webServer.ListenAndServe(addr); err != nil { + log.Printf("Web server error: %v", err) + } + }() + } + + // Start periodic tasks + go s.runPeriodicTasks() + + return nil +} + +func (s *LoginServer) runPeriodicTasks() { + ticker := time.NewTicker(time.Minute) + defer ticker.Stop() + + for { + select { + case <-ticker.C: + s.clients.CleanupExpired() + s.worlds.UpdateStats() + case <-s.ctx.Done(): + return + } + } +} + +func (s *LoginServer) shutdown() { + s.mu.Lock() + s.running = false + s.mu.Unlock() + + s.cancel() + + if s.webServer != nil { + s.webServer.Shutdown() + } + + if s.db != nil { + s.db.Close() + } +} + +func (s *LoginServer) printHeader() { + log.Println("===============================================") + log.Println(" EverQuest II Login Server - Go Edition") + log.Println(" High Performance Game Authentication Server") + log.Println("===============================================") + log.Printf("Server Port: %d", s.config.Server.Port) + if s.config.Web.Enabled { + log.Printf("Web Interface: %s:%d", s.config.Web.Address, s.config.Web.Port) + } + log.Println("Server starting...") +} diff --git a/cmd/loginServer/opcodes.go b/cmd/loginServer/opcodes.go new file mode 100644 index 0000000..d8d01e7 --- /dev/null +++ b/cmd/loginServer/opcodes.go @@ -0,0 +1,143 @@ +package main + +import ( + "crypto/rand" + "encoding/hex" + "errors" +) + +// Opcodes +const ( + OpLoginRequest uint16 = 0x0001 + OpLoginReply uint16 = 0x0002 + OpWorldListRequest uint16 = 0x0003 + OpWorldListReply uint16 = 0x0004 + OpCharacterListRequest uint16 = 0x0005 + OpCharacterListReply uint16 = 0x0006 + OpCreateCharacter uint16 = 0x0007 + OpCreateCharacterReply uint16 = 0x0008 + OpDeleteCharacter uint16 = 0x0009 + OpDeleteCharacterReply uint16 = 0x000A + OpPlayCharacter uint16 = 0x000B + OpPlayCharacterReply uint16 = 0x000C + OpError uint16 = 0xFFFF +) + +var ErrIncompletePacket = errors.New("incomplete packet") + +type EQ2Packet struct { + Opcode uint16 + Size uint16 + Data []byte +} + +type LoginRequest struct { + Username string `json:"username"` + Password string `json:"password"` + Version int16 `json:"version"` +} + +type LoginResponse struct { + Response uint8 `json:"response"` + AccountID uint32 `json:"account_id"` + SubLevel uint32 `json:"sub_level"` + RaceFlag uint32 `json:"race_flag"` + ClassFlag uint32 `json:"class_flag"` + Username string `json:"username"` + Unknown5 uint32 `json:"unknown5"` + CitiesFlag uint8 `json:"cities_flag"` + Reason string `json:"reason,omitempty"` +} + +type WorldInfo struct { + ID uint32 `json:"id"` + Name string `json:"name"` + Status uint8 `json:"status"` + Players uint32 `json:"players"` + MaxPlayers uint32 `json:"max_players"` + Address string `json:"address"` + Port uint16 `json:"port"` + Locked bool `json:"locked"` +} + +type WorldListResponse struct { + NumWorlds uint32 `json:"num_worlds"` + Worlds []*WorldInfo `json:"worlds"` +} + +type Character struct { + ID uint32 `json:"id"` + Name string `json:"name"` + Race uint8 `json:"race"` + Class uint8 `json:"class"` + Gender uint8 `json:"gender"` + Level uint8 `json:"level"` + Zone string `json:"zone"` + ServerID uint32 `json:"server_id"` + Created int64 `json:"created"` + LastLogin int64 `json:"last_login"` +} + +type CharacterListResponse struct { + NumCharacters uint32 `json:"num_characters"` + Characters []*Character `json:"characters"` + AccountID uint32 `json:"account_id"` + MaxChars uint32 `json:"max_chars"` +} + +type CreateCharacterRequest struct { + Name string `json:"name"` + Race uint8 `json:"race"` + Class uint8 `json:"class"` + Gender uint8 `json:"gender"` + Deity uint8 `json:"deity"` + BodySize float32 `json:"body_size"` + BodyAge float32 `json:"body_age"` + ServerID uint32 `json:"server_id"` +} + +type CreateCharacterResponse struct { + Success bool `json:"success"` + CharacterID uint32 `json:"character_id"` + Name string `json:"name"` + Error string `json:"error,omitempty"` +} + +type DeleteCharacterRequest struct { + CharacterID uint32 `json:"character_id"` + ServerID uint32 `json:"server_id"` +} + +type DeleteCharacterResponse struct { + Success bool `json:"success"` + CharacterID uint32 `json:"character_id"` + Error string `json:"error,omitempty"` +} + +type PlayCharacterRequest struct { + CharacterID uint32 `json:"character_id"` + ServerID uint32 `json:"server_id"` +} + +type PlayCharacterResponse struct { + Success bool `json:"success"` + ServerIP string `json:"server_ip"` + ServerPort uint16 `json:"server_port"` + SessionKey string `json:"session_key"` + Error string `json:"error,omitempty"` +} + +type OpcodeManager struct { + opcodes map[string]uint16 +} + +func (om *OpcodeManager) GetOpcode(name string) (uint16, bool) { + opcode, exists := om.opcodes[name] + return opcode, exists +} + +func generateSessionKey() string { + bytes := make([]byte, 16) + rand.Read(bytes) + return hex.EncodeToString(bytes) +} diff --git a/cmd/loginServer/tcp.go b/cmd/loginServer/tcp.go new file mode 100644 index 0000000..b14f2a9 --- /dev/null +++ b/cmd/loginServer/tcp.go @@ -0,0 +1,300 @@ +package main + +import ( + "encoding/binary" + "log" + "time" + + "github.com/goccy/go-json" + "github.com/panjf2000/gnet/v2" +) + +type TCPServer struct { + gnet.BuiltinEventEngine + server *LoginServer + clients *ClientManager + worlds *WorldManager +} + +func (s *TCPServer) OnBoot(eng gnet.Engine) gnet.Action { + log.Printf("TCP server started on %s", eng.Addr()) + return gnet.None +} + +func (s *TCPServer) OnOpen(c gnet.Conn) ([]byte, gnet.Action) { + addr := c.RemoteAddr().String() + log.Printf("New connection from %s", addr) + + client := &Client{ + conn: c, + address: addr, + connected: time.Now(), + state: StateConnected, + version: 0, + } + + s.clients.AddClient(c.Fd(), client) + return nil, gnet.None +} + +func (s *TCPServer) OnClose(c gnet.Conn, err error) gnet.Action { + s.clients.RemoveClient(c.Fd()) + if err != nil { + log.Printf("Connection closed with error: %v", err) + } + return gnet.None +} + +func (s *TCPServer) OnTraffic(c gnet.Conn) gnet.Action { + client := s.clients.GetClient(c.Fd()) + if client == nil { + return gnet.Close + } + + for { + packet, err := s.readPacket(c) + if err != nil { + if err != ErrIncompletePacket { + log.Printf("Error reading packet: %v", err) + return gnet.Close + } + break + } + + if err := s.handlePacket(client, packet); err != nil { + log.Printf("Error handling packet: %v", err) + return gnet.Close + } + } + + return gnet.None +} + +func (s *TCPServer) readPacket(c gnet.Conn) (*EQ2Packet, error) { + // Read packet header (2 bytes length + 2 bytes opcode) + if c.InboundBuffered() < 4 { + return nil, ErrIncompletePacket + } + + header := make([]byte, 4) + if _, err := c.Peek(header); err != nil { + return nil, err + } + + length := binary.LittleEndian.Uint16(header[0:2]) + opcode := binary.LittleEndian.Uint16(header[2:4]) + + totalLength := int(length) + 4 // Add header size + if c.InboundBuffered() < totalLength { + return nil, ErrIncompletePacket + } + + // Read complete packet + data := make([]byte, totalLength) + if _, err := c.Read(data); err != nil { + return nil, err + } + + return &EQ2Packet{ + Opcode: opcode, + Size: length, + Data: data[4:], // Skip header + }, nil +} + +func (s *TCPServer) handlePacket(client *Client, packet *EQ2Packet) error { + switch packet.Opcode { + case OpLoginRequest: + return s.handleLoginRequest(client, packet) + case OpWorldListRequest: + return s.handleWorldListRequest(client, packet) + case OpCharacterListRequest: + return s.handleCharacterListRequest(client, packet) + case OpCreateCharacter: + return s.handleCreateCharacter(client, packet) + case OpDeleteCharacter: + return s.handleDeleteCharacter(client, packet) + case OpPlayCharacter: + return s.handlePlayCharacter(client, packet) + default: + log.Printf("Unknown opcode: 0x%04X", packet.Opcode) + } + return nil +} + +func (s *TCPServer) handleLoginRequest(client *Client, packet *EQ2Packet) error { + var loginReq LoginRequest + if err := json.Unmarshal(packet.Data, &loginReq); err != nil { + return s.sendLoginDenied(client, "Invalid login data") + } + + account, err := s.server.db.Get(s.server.ctx) + if err != nil { + return s.sendLoginDenied(client, "Database error") + } + defer s.server.db.Put(account) + + // Authenticate user + authenticated, accountID, err := authenticateUser(account, loginReq.Username, loginReq.Password, s.server.config.Game.AllowAccountCreation) + if err != nil { + return s.sendLoginDenied(client, "Authentication failed") + } + + if !authenticated { + return s.sendLoginDenied(client, "Invalid credentials") + } + + client.accountID = accountID + client.accountName = loginReq.Username + client.state = StateAuthenticated + client.version = loginReq.Version + + return s.sendLoginAccepted(client) +} + +func (s *TCPServer) sendLoginAccepted(client *Client) error { + response := LoginResponse{ + Response: 1, + AccountID: client.accountID, + SubLevel: s.server.config.Game.DefaultSubscriptionLevel, + RaceFlag: s.server.config.Game.EnabledRaces, + ClassFlag: 0x7FFFFFE, + Username: client.accountName, + Unknown5: s.server.config.Game.ExpansionFlag, + CitiesFlag: s.server.config.Game.CitiesFlag, + } + + return s.sendPacket(client, OpLoginReply, &response) +} + +func (s *TCPServer) sendLoginDenied(client *Client, reason string) error { + response := LoginResponse{ + Response: 0, + Reason: reason, + } + return s.sendPacket(client, OpLoginReply, &response) +} + +func (s *TCPServer) handleWorldListRequest(client *Client, packet *EQ2Packet) error { + if client.state != StateAuthenticated { + return s.sendError(client, "Not authenticated") + } + + worlds := s.worlds.GetWorldList() + worldList := WorldListResponse{ + NumWorlds: uint32(len(worlds)), + Worlds: worlds, + } + + return s.sendPacket(client, OpWorldListReply, &worldList) +} + +func (s *TCPServer) handleCharacterListRequest(client *Client, packet *EQ2Packet) error { + if client.state != StateAuthenticated { + return s.sendError(client, "Not authenticated") + } + + conn := s.server.db.Get(s.server.ctx) + defer s.server.db.Put(conn) + + characters, err := getCharacterList(conn, client.accountID) + if err != nil { + return s.sendError(client, "Failed to load characters") + } + + charList := CharacterListResponse{ + NumCharacters: uint32(len(characters)), + Characters: characters, + AccountID: client.accountID, + MaxChars: uint32(s.server.config.Game.MaxCharactersPerAccount), + } + + return s.sendPacket(client, OpCharacterListReply, &charList) +} + +func (s *TCPServer) sendPacket(client *Client, opcode uint16, data any) error { + jsonData, err := json.Marshal(data) + if err != nil { + return err + } + + packet := make([]byte, 4+len(jsonData)) + binary.LittleEndian.PutUint16(packet[0:2], uint16(len(jsonData))) + binary.LittleEndian.PutUint16(packet[2:4], opcode) + copy(packet[4:], jsonData) + + _, err = client.conn.Write(packet) + return err +} + +func (s *TCPServer) sendError(client *Client, message string) error { + return s.sendPacket(client, OpError, map[string]string{"error": message}) +} + +func (s *TCPServer) handleCreateCharacter(client *Client, packet *EQ2Packet) error { + var createReq CreateCharacterRequest + if err := json.Unmarshal(packet.Data, &createReq); err != nil { + return s.sendError(client, "Invalid character data") + } + + conn := s.server.db.Get(s.server.ctx) + defer s.server.db.Put(conn) + + charID, err := createCharacter(conn, client.accountID, &createReq) + if err != nil { + return s.sendError(client, "Failed to create character") + } + + response := CreateCharacterResponse{ + Success: true, + CharacterID: charID, + Name: createReq.Name, + } + + return s.sendPacket(client, OpCreateCharacterReply, &response) +} + +func (s *TCPServer) handleDeleteCharacter(client *Client, packet *EQ2Packet) error { + var deleteReq DeleteCharacterRequest + if err := json.Unmarshal(packet.Data, &deleteReq); err != nil { + return s.sendError(client, "Invalid delete request") + } + + conn := s.server.db.Get(s.server.ctx) + defer s.server.db.Put(conn) + + if err := deleteCharacter(conn, client.accountID, deleteReq.CharacterID); err != nil { + return s.sendError(client, "Failed to delete character") + } + + response := DeleteCharacterResponse{ + Success: true, + CharacterID: deleteReq.CharacterID, + } + + return s.sendPacket(client, OpDeleteCharacterReply, &response) +} + +func (s *TCPServer) handlePlayCharacter(client *Client, packet *EQ2Packet) error { + var playReq PlayCharacterRequest + if err := json.Unmarshal(packet.Data, &playReq); err != nil { + return s.sendError(client, "Invalid play request") + } + + world := s.worlds.GetWorld(playReq.ServerID) + if world == nil { + return s.sendError(client, "World server not available") + } + + // Generate session key and send to world server + sessionKey := generateSessionKey() + + response := PlayCharacterResponse{ + Success: true, + ServerIP: world.Address, + ServerPort: world.Port, + SessionKey: sessionKey, + } + + return s.sendPacket(client, OpPlayCharacterReply, &response) +} diff --git a/cmd/loginServer/web.go b/cmd/loginServer/web.go new file mode 100644 index 0000000..a695eb2 --- /dev/null +++ b/cmd/loginServer/web.go @@ -0,0 +1,263 @@ +package main + +import ( + "encoding/base64" + "strings" + "time" + + "github.com/goccy/go-json" + "github.com/valyala/fasthttp" +) + +type WebRouter struct { + server *LoginServer +} + +func (wr *WebRouter) Handler(ctx *fasthttp.RequestCtx) { + path := string(ctx.Path()) + + // Basic auth check + if !wr.checkAuth(ctx) { + ctx.Response.Header.Set("WWW-Authenticate", `Basic realm="EQ2 Login Server"`) + ctx.SetStatusCode(fasthttp.StatusUnauthorized) + ctx.SetBodyString("Unauthorized") + return + } + + switch path { + case "/": + wr.handleStatus(ctx) + case "/status": + wr.handleStatus(ctx) + case "/worlds": + wr.handleWorlds(ctx) + case "/clients": + wr.handleClients(ctx) + case "/stats": + wr.handleStats(ctx) + default: + ctx.SetStatusCode(fasthttp.StatusNotFound) + ctx.SetBodyString("Not Found") + } +} + +func (wr *WebRouter) checkAuth(ctx *fasthttp.RequestCtx) bool { + if wr.server.config.Web.Username == "" { + return true // No auth required + } + + auth := ctx.Request.Header.Peek("Authorization") + if len(auth) == 0 { + return false + } + + if !strings.HasPrefix(string(auth), "Basic ") { + return false + } + + encoded := string(auth[6:]) + decoded, err := base64.StdEncoding.DecodeString(encoded) + if err != nil { + return false + } + + parts := strings.SplitN(string(decoded), ":", 2) + if len(parts) != 2 { + return false + } + + return parts[0] == wr.server.config.Web.Username && + parts[1] == wr.server.config.Web.Password +} + +func (wr *WebRouter) handleStatus(ctx *fasthttp.RequestCtx) { + ctx.Response.Header.Set("Content-Type", "application/json") + + totalClients, authClients := wr.server.clients.GetStats() + totalWorlds, onlineWorlds := wr.server.worlds.GetStats() + + conn := wr.server.db.Get(wr.server.ctx) + defer wr.server.db.Put(conn) + + totalAccounts, totalChars, _ := getAccountStats(conn) + + status := map[string]any{ + "server_name": "EQ2 Login Server", + "status": "online", + "uptime": time.Since(wr.server.startTime).Seconds(), + "uptime_string": formatDuration(time.Since(wr.server.startTime)), + "version": "1.0.0-go", + "clients": map[string]int{ + "total": totalClients, + "authenticated": authClients, + }, + "worlds": map[string]int{ + "total": totalWorlds, + "online": onlineWorlds, + }, + "database": map[string]int{ + "accounts": totalAccounts, + "characters": totalChars, + }, + "timestamp": time.Now().Unix(), + } + + data, _ := json.Marshal(status) + ctx.SetBody(data) +} + +func (wr *WebRouter) handleWorlds(ctx *fasthttp.RequestCtx) { + ctx.Response.Header.Set("Content-Type", "application/json") + + worlds := wr.server.worlds.GetWorldList() + + response := map[string]any{ + "worlds": worlds, + "count": len(worlds), + } + + data, _ := json.Marshal(response) + ctx.SetBody(data) +} + +func (wr *WebRouter) handleClients(ctx *fasthttp.RequestCtx) { + ctx.Response.Header.Set("Content-Type", "application/json") + + wr.server.clients.mu.RLock() + defer wr.server.clients.mu.RUnlock() + + clients := make([]map[string]any, 0, len(wr.server.clients.clients)) + + for _, client := range wr.server.clients.clients { + clients = append(clients, map[string]any{ + "address": client.address, + "connected": client.connected.Unix(), + "state": stateToString(client.state), + "account_name": client.accountName, + "version": client.version, + }) + } + + response := map[string]any{ + "clients": clients, + "count": len(clients), + } + + data, _ := json.Marshal(response) + ctx.SetBody(data) +} + +func (wr *WebRouter) handleStats(ctx *fasthttp.RequestCtx) { + ctx.Response.Header.Set("Content-Type", "application/json") + + // Get comprehensive stats + totalClients, authClients := wr.server.clients.GetStats() + totalWorlds, onlineWorlds := wr.server.worlds.GetStats() + + conn := wr.server.db.Get(wr.server.ctx) + defer wr.server.db.Put(conn) + + totalAccounts, totalChars, _ := getAccountStats(conn) + + stats := map[string]any{ + "server": map[string]any{ + "uptime": time.Since(wr.server.startTime).Seconds(), + "start_time": wr.server.startTime.Unix(), + "version": "1.0.0-go", + }, + "clients": map[string]any{ + "total": totalClients, + "authenticated": authClients, + "guest": totalClients - authClients, + }, + "worlds": map[string]any{ + "total": totalWorlds, + "online": onlineWorlds, + "offline": totalWorlds - onlineWorlds, + }, + "database": map[string]any{ + "accounts": totalAccounts, + "characters": totalChars, + "avg_chars": float64(totalChars) / float64(max(totalAccounts, 1)), + }, + "config": map[string]any{ + "max_clients": wr.server.config.Server.MaxClients, + "max_world_servers": wr.server.config.Server.MaxWorldServers, + "allow_account_creation": wr.server.config.Game.AllowAccountCreation, + "max_chars_per_account": wr.server.config.Game.MaxCharactersPerAccount, + }, + } + + data, _ := json.Marshal(stats) + ctx.SetBody(data) +} + +func stateToString(state ClientState) string { + switch state { + case StateConnected: + return "connected" + case StateAuthenticated: + return "authenticated" + case StateCharacterSelect: + return "character_select" + case StateDisconnected: + return "disconnected" + default: + return "unknown" + } +} + +func formatDuration(d time.Duration) string { + days := int(d.Hours()) / 24 + hours := int(d.Hours()) % 24 + minutes := int(d.Minutes()) % 60 + + if days > 0 { + return formatTime(days, "day") + ", " + formatTime(hours, "hour") + ", " + formatTime(minutes, "minute") + } + if hours > 0 { + return formatTime(hours, "hour") + ", " + formatTime(minutes, "minute") + } + return formatTime(minutes, "minute") +} + +func formatTime(value int, unit string) string { + if value == 1 { + return "1 " + unit + } + return string(rune(value)) + " " + unit + "s" +} + +func max(a, b int) int { + if a > b { + return a + } + return b +} + +// Example login_config.json file +const ExampleConfig = `{ + "server": { + "port": 5998, + "max_clients": 1000, + "max_world_servers": 10 + }, + "database": { + "path": "login.db" + }, + "web": { + "enabled": true, + "address": "0.0.0.0", + "port": 8080, + "username": "admin", + "password": "password" + }, + "game": { + "allow_account_creation": true, + "expansion_flag": 32767, + "cities_flag": 255, + "default_subscription_level": 4294967295, + "enabled_races": 65535, + "max_characters_per_account": 7 + } +}` diff --git a/cmd/loginServer/worlds.go b/cmd/loginServer/worlds.go new file mode 100644 index 0000000..63b66fc --- /dev/null +++ b/cmd/loginServer/worlds.go @@ -0,0 +1,103 @@ +package main + +import ( + "sync" + "time" + + "github.com/panjf2000/gnet/v2" + "zombiezen.com/go/sqlite/sqlitex" +) + +type WorldServer struct { + ID uint32 + Name string + Address string + Port uint16 + Status uint8 + Players uint32 + MaxPlayers uint32 + Locked bool + LastUpdate time.Time + conn gnet.Conn + mu sync.RWMutex +} + +type WorldManager struct { + worlds map[uint32]*WorldServer + db *sqlitex.Pool + mu sync.RWMutex +} + +func NewWorldManager(db *sqlitex.Pool) *WorldManager { + return &WorldManager{ + worlds: make(map[uint32]*WorldServer), + db: db, + } +} + +func (wm *WorldManager) AddWorld(world *WorldServer) { + wm.mu.Lock() + defer wm.mu.Unlock() + wm.worlds[world.ID] = world +} + +func (wm *WorldManager) RemoveWorld(id uint32) { + wm.mu.Lock() + defer wm.mu.Unlock() + delete(wm.worlds, id) +} + +func (wm *WorldManager) GetWorld(id uint32) *WorldServer { + wm.mu.RLock() + defer wm.mu.RUnlock() + return wm.worlds[id] +} + +func (wm *WorldManager) GetWorldList() []*WorldInfo { + wm.mu.RLock() + defer wm.mu.RUnlock() + + worlds := make([]*WorldInfo, 0, len(wm.worlds)) + for _, world := range wm.worlds { + worlds = append(worlds, &WorldInfo{ + ID: world.ID, + Name: world.Name, + Status: world.Status, + Players: world.Players, + MaxPlayers: world.MaxPlayers, + Address: world.Address, + Port: world.Port, + Locked: world.Locked, + }) + } + + return worlds +} + +func (wm *WorldManager) UpdateStats() { + wm.mu.Lock() + defer wm.mu.Unlock() + + cutoff := time.Now().Add(-5 * time.Minute) + for _, world := range wm.worlds { + if world.LastUpdate.Before(cutoff) { + world.Status = 0 // Offline + } + } +} + +func (wm *WorldManager) GetStats() (int, int) { + wm.mu.RLock() + defer wm.mu.RUnlock() + + total := len(wm.worlds) + online := 0 + + for _, world := range wm.worlds { + if world.Status == 1 { + online++ + } + } + + return total, online +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..2170441 --- /dev/null +++ b/go.mod @@ -0,0 +1,29 @@ +module eq2emu + +go 1.24.1 + +require ( + github.com/andybalholm/brotli v1.2.0 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/goccy/go-json v0.10.5 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/klauspost/compress v1.18.0 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/ncruces/go-strftime v0.1.9 // indirect + github.com/panjf2000/ants/v2 v2.11.3 // indirect + github.com/panjf2000/gnet/v2 v2.9.1 // indirect + github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect + github.com/valyala/bytebufferpool v1.0.0 // indirect + github.com/valyala/fasthttp v1.63.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect + golang.org/x/sync v0.15.0 // indirect + golang.org/x/sys v0.33.0 // indirect + gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect + modernc.org/libc v1.65.7 // indirect + modernc.org/mathutil v1.7.1 // indirect + modernc.org/memory v1.11.0 // indirect + modernc.org/sqlite v1.37.1 // indirect + zombiezen.com/go/sqlite v1.4.2 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..90e8082 --- /dev/null +++ b/go.sum @@ -0,0 +1,47 @@ +github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ= +github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= +github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4= +github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= +github.com/panjf2000/ants/v2 v2.11.3 h1:AfI0ngBoXJmYOpDh9m516vjqoUu2sLrIVgppI9TZVpg= +github.com/panjf2000/ants/v2 v2.11.3/go.mod h1:8u92CYMUc6gyvTIw8Ru7Mt7+/ESnJahz5EVtqfrilek= +github.com/panjf2000/gnet/v2 v2.9.1 h1:bKewICy/0xnQ9PMzNaswpe/Ah14w1TrRk91LHTcbIlA= +github.com/panjf2000/gnet/v2 v2.9.1/go.mod h1:WQTxDWYuQ/hz3eccH0FN32IVuvZ19HewEWx0l62fx7E= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= +github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasthttp v1.63.0 h1:DisIL8OjB7ul2d7cBaMRcKTQDYnrGy56R4FCiuDP0Ns= +github.com/valyala/fasthttp v1.63.0/go.mod h1:REc4IeW+cAEyLrRPa5A81MIjvz0QE1laoTX2EaPHKJM= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8= +golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8= +golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= +golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= +gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= +modernc.org/libc v1.65.7 h1:Ia9Z4yzZtWNtUIuiPuQ7Qf7kxYrxP1/jeHZzG8bFu00= +modernc.org/libc v1.65.7/go.mod h1:011EQibzzio/VX3ygj1qGFt5kMjP0lHb0qCW5/D/pQU= +modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= +modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= +modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= +modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= +modernc.org/sqlite v1.37.1 h1:EgHJK/FPoqC+q2YBXg7fUmES37pCHFc97sI7zSayBEs= +modernc.org/sqlite v1.37.1/go.mod h1:XwdRtsE1MpiBcL54+MbKcaDvcuej+IYSMfLN6gSKV8g= +zombiezen.com/go/sqlite v1.4.2 h1:KZXLrBuJ7tKNEm+VJcApLMeQbhmAUOKA5VWS93DfFRo= +zombiezen.com/go/sqlite v1.4.2/go.mod h1:5Kd4taTAD4MkBzT25mQ9uaAlLjyR0rFhsR6iINO70jc= diff --git a/internal/opcodes/game.go b/internal/opcodes/game.go new file mode 100644 index 0000000..6e01e30 --- /dev/null +++ b/internal/opcodes/game.go @@ -0,0 +1,469 @@ +package opcodes + +// Game application opcodes from emu_oplist.h +const ( + OP_Unknown = 0 + + // Core game messages + OP_ESInitMsg = iota + 100 + OP_ESReadyForClientsMsg + OP_CreateZoneInstanceMsg + OP_ZoneInstanceCreateReplyMsg + OP_ZoneInstanceDestroyedMsg + OP_ExpectClientAsCharacterRequest + OP_ExpectClientAsCharacterReplyMsg + OP_ZoneInfoMsg + OP_DoneLoadingZoneResourcesMsg + OP_DoneSendingInitialEntitiesMsg + OP_DoneLoadingEntityResourcesMsg + OP_DoneLoadingUIResourcesMsg + OP_PredictionUpdateMsg + OP_RemoteCmdMsg + OP_SetRemoteCmdsMsg + OP_GameWorldTimeMsg + OP_MOTDMsg + OP_ZoneMOTDMsg + + // Guild recruiting + OP_GuildRecruitingMemberInfo + OP_GuildRecruiting + OP_GuildRecruitingDetails + OP_GuildRecruitingImage + + // Avatar management + OP_AvatarCreatedMsg + OP_AvatarDestroyedMsg + OP_RequestCampMsg + OP_MapRequest + OP_CampStartedMsg + OP_CampAbortedMsg + + // Communication + OP_WhoQueryRequestMsg + OP_WhoQueryReplyMsg + OP_MonitorReplyMsg + OP_MonitorCharacterListMsg + OP_MonitorCharacterListRequestMsg + OP_ClientCmdMsg + OP_Lottery + OP_DispatchClientCmdMsg + OP_DispatchESMsg + + // Updates + OP_UpdateTargetMsg + OP_UpdateOpportunityMsg + OP_UpdateTargetLocMsg + OP_UpdateSpellBookMsg + OP_UpdateRecipeBookMsg + OP_RequestRecipeDetailsMsg + OP_RecipeDetailsMsg + OP_UpdateSkillBookMsg + OP_UpdateSkillsMsg + + // Zone management + OP_ChangeZoneMsg + OP_ClientTeleportRequestMsg + OP_TeleportWithinZoneMsg + OP_TeleportWithinZoneNoReloadMsg + OP_MigrateClientToZoneRequestMsg + OP_MigrateClientToZoneReplyMsg + OP_ReadyToZoneMsg + + // Group management + OP_RemoveClientFromGroupMsg + OP_RemoveGroupFromGroupMsg + OP_MakeGroupLeaderMsg + OP_GroupCreatedMsg + OP_GroupDestroyedMsg + OP_GroupMemberAddedMsg + OP_GroupMemberRemovedMsg + OP_GroupRemovedFromGroupMsg + OP_GroupLeaderChangedMsg + OP_GroupSettingsChangedMsg + + // Status and control + OP_SendLatestRequestMsg + OP_ClearDataMsg + OP_SetSocialMsg + OP_ESStatusMsg + OP_ESZoneInstanceStatusMsg + OP_ZonesStatusRequestMsg + OP_ZonesStatusMsg + OP_ESWeatherRequestMsg + OP_ESWeatherRequestEndMsg + + // Loot and items + OP_LootItemsRequestMsg + OP_StoppedLootingMsg + + // Character actions + OP_SitMsg + OP_StandMsg + OP_SatMsg + OP_StoodMsg + + // UI and interface + OP_DefaultGroupOptionsRequestMsg + OP_DefaultGroupOptionsMsg + OP_GroupOptionsMsg + OP_DisplayGroupOptionsScreenMsg + OP_DisplayInnVisitScreenMsg + OP_DumpSchedulerMsg + OP_RequestHelpRepathMsg + OP_UpdateMotdMsg + OP_RequestTargetLocMsg + + // Effects and actions + OP_PerformPlayerKnockbackMsg + OP_PerformCameraShakeMsg + OP_PopulateSkillMapsMsg + OP_CancelledFeignMsg + OP_SignalMsg + + // Skills and crafting + OP_SkillInfoRequest + OP_SkillInfoResponse + OP_ShowCreateFromRecipeUIMsg + OP_CancelCreateFromRecipeMsg + OP_BeginItemCreationMsg + OP_StopItemCreationMsg + OP_ShowItemCreationProcessUIMsg + OP_UpdateItemCreationProcessUIMsg + OP_DisplayTSEventReactionMsg + OP_ShowRecipeBookMsg + + // Knowledge and help + OP_KnowledgebaseRequestMsg + OP_KnowledgebaseResponseMsg + + // Customer service + OP_CSTicketHeaderRequestMsg + OP_CSTicketInfoMsg + OP_CSTicketCommentRequestMsg + OP_CSTicketCommentResponseMsg + OP_CSTicketCreateMsg + OP_CSTicketAddCommentMsg + OP_CSTicketDeleteMsg + OP_CSTicketChangeNotificationMsg + + // World data + OP_WorldDataUpdateMsg + OP_WorldDataChangeMsg + OP_KnownLanguagesMsg + + // Client management + OP_ClientTeleportToLocationMsg + OP_UpdateClientPredFlagsMsg + OP_ChangeServerControlFlagMsg + OP_CSToolsRequestMsg + OP_CSToolsResponseMsg + + // Transport + OP_CreateBoatTransportsMsg + OP_PositionBoatTransportMsg + OP_MigrateBoatTransportMsg + OP_MigrateBoatTransportReplyMsg + + // Debug and examination + OP_DisplayDebugNLLPointsMsg + OP_ExamineInfoRequestMsg + + // UI management + OP_QuickbarInitMsg + OP_QuickbarUpdateMsg + OP_MacroInitMsg + OP_MacroUpdateMsg + OP_QuestionnaireMsg + + // Character progression + OP_LevelChangedMsg + OP_SpellGainedMsg + OP_EncounterBrokenMsg + OP_OnscreenMsgMsg + OP_DisplayWarningMsg + + // Guild management + OP_ModifyGuildMsg + OP_GuildEventMsg + OP_GuildEventAddMsg + OP_GuildEventActionMsg + OP_GuildEventListMsg + OP_RequestGuildEventDetailsMsg + OP_GuildEventDetailsMsg + OP_RequestGuildBankEventDetailsMsg + OP_GuildBankUpdateMsg + OP_RewardPackMsg + OP_RenameGuildMsg + + // Social features + OP_ZoneToFriendRequestMsg + OP_ZoneToFriendReplyMsg + OP_WaypointRequestMsg + OP_WaypointReplyMsg + OP_WaypointSelectMsg + OP_WaypointUpdateMsg + OP_CharNameChangedMsg + + // Travel + OP_ShowZoneTeleporterDestinations + OP_SelectZoneTeleporterDestination + OP_ReloadLocalizedTxtMsg + + // Guild membership + OP_RequestGuildMembershipMsg + OP_GuildMembershipResponseMsg + OP_LeaveGuildNotifyMsg + OP_JoinGuildNotifyMsg + OP_RequestGuildInfoMsg + OP_GuildBankEventListMsg + + // Character info + OP_AvatarUpdateMsg + OP_BioUpdateMsg + OP_InspectPlayerMsg + + // Server management + OP_CsCategoryRequestMsg + OP_CsCategoryResponseMsg + OP_KnowledgeWindowSlotMappingMsg + + // Status updates + OP_LFGUpdateMsg + OP_AFKUpdateMsg + OP_AnonUpdateMsg + OP_UpdateActivePublicZonesMsg + OP_UnknownNpcMsg + OP_PromoFlagsDetailsMsg + + // Trading and consignment + OP_ConsignViewCreateMsg + OP_ConsignViewGetPageMsg + OP_ConsignViewReleaseMsg + OP_UpdateDebugRadiiMsg + OP_ConsignRemoveItemsMsg + OP_ReportMsg + OP_UpdateRaidMsg + OP_ConsignViewSortMsg + + // Character features + OP_TitleUpdateMsg + OP_FlightPathsMsg + OP_ClientFellMsg + OP_ClientInDeathRegionMsg + OP_CampClientMsg + + // Customer service tools + OP_GetAvatarAccessRequestForCSTools + OP_CSToolAccessResponseMsg + OP_DeleteGuildMsg + + // Tracking + OP_TrackingUpdateMsg + OP_BeginTrackingMsg + OP_StopTrackingMsg + OP_AdvancementRequestMsg + + // Map data + OP_MapFogDataInitMsg + OP_MapFogDataUpdateMsg + OP_CloseGroupInviteWindowMsg + OP_UpdateGroupMemberDataMsg + OP_WorldPingMsg + OP_MoveLogUpdateMsg + OP_OfferQuestMsg + + // Mail system + OP_MailGetMessageMsg + OP_MailSendMessageMsg + OP_MailDeleteMessageMsg + OP_MailGetHeadersReplyMsg + OP_MailGetMessageReplyMsg + OP_MailSendMessageReplyMsg + OP_MailCommitSendMessageMsg + OP_MailSendSystemMessageMsg + OP_MailRemoveAttachFromMailMsg + OP_WorldShutdownUpdateMsg + OP_ClientIdleBeginMsg + OP_ClientIdleEndMsg + OP_DisplayMailScreenMsg + OP_NotifyApprenticeStoppedMentoring + OP_CorruptedClientMsg + OP_MailEventNotificationMsg + OP_RestartZoneMsg + + // Character transfer + OP_CharTransferStartRequestMsg + OP_CharTransferStartReplyMsg + OP_CharTransferRequestMsg + OP_CharTransferReplyMsg + OP_CharTransferRollbackRequestMsg + OP_CharTransferCommitRequestMsg + OP_CharTransferRollbackReplyMsg + OP_CharTransferCommitReplyMsg + OP_GetCharacterSerializedRequestMsg + OP_GetCharacterSerializedReplyMsg + OP_CreateCharFromCBBRequestMsg + OP_CreateCharFromCBBReplyMsg + + // Housing + OP_HousingDataChangedMsg + OP_HousingRestoreMsg + + // Auction system + OP_AuctionItem + OP_AuctionItemReply + OP_AuctionCoin + OP_AuctionCoinReply + OP_AuctionCharacter + OP_AuctionCharacterReply + OP_AuctionCommitMsg + OP_AuctionAbortMsg + OP_CharTransferValidateRequestMsg + OP_CharTransferValidateReplyMsg + OP_CharacterLinkdeadMsg + OP_RaceRestrictionMsg + OP_SetInstanceDisplayNameMsg + + // EQ command system + OP_EqHearChatCmd + OP_EqDisplayTextCmd + OP_EqCreateGhostCmd + OP_EqCreateWidgetCmd + OP_EqCreateSignWidgetCmd + OP_EqDestroyGhostCmd + OP_EqUpdateGhostCmd + OP_EqSetControlGhostCmd + OP_EqSetPOVGhostCmd + OP_EqHearCombatCmd + OP_EqHearSpellCastCmd + OP_EqHearSpellInterruptCmd + OP_EqHearSpellFizzleCmd + OP_EqHearConsiderCmd + OP_EqUpdateSubClassesCmd + OP_EqCreateListBoxCmd + OP_EqSetDebugPathPointsCmd + OP_EqCannedEmoteCmd + OP_EqStateCmd + OP_EqPlaySoundCmd + OP_EqPlaySound3DCmd + OP_EqPlayVoiceCmd + OP_EqHearDrowningCmd + OP_EqHearDeathCmd + OP_EqGroupMemberRemovedCmd + OP_EqHearChainEffectCmd + OP_EqReceiveOfferCmd + OP_EqInspectPCResultsCmd + OP_EqDrawablePathGraphCmd + OP_EqDialogOpenCmd + OP_EqDialogCloseCmd + OP_EqCollectionUpdateCmd + OP_EqCollectionFilterCmd + OP_EqCollectionItemCmd + OP_EqQuestJournalUpdateCmd + OP_EqQuestJournalReplyCmd + OP_EqQuestGroupCmd + OP_EqUpdateMerchantCmd + OP_EqUpdateStoreCmd + OP_EqUpdatePlayerTradeCmd + OP_EqHelpPathCmd + OP_EqHelpPathClearCmd + OP_EqUpdateBankCmd + OP_EqExamineInfoCmd + OP_EqCloseWindowCmd + OP_EqUpdateLootCmd + OP_EqJunctionListCmd + OP_EqShowDeathWindowCmd + OP_EqDisplaySpellFailCmd + OP_EqSpellCastStartCmd + OP_EqSpellCastEndCmd + OP_EqResurrectedCmd + OP_EqChoiceWinCmd + OP_EqSetDefaultVerbCmd + OP_EqInstructionWindowCmd + OP_EqInstructionWindowCloseCmd + OP_EqInstructionWindowGoalCmd + OP_EqInstructionWindowTaskCmd + OP_EqEnableGameEventCmd + OP_EqShowWindowCmd + OP_EqEnableWindowCmd + OP_EqFlashWindowCmd + OP_EqHearPlayFlavorCmd + OP_EqUpdateSignWidgetCmd + OP_EqDebugPVDCmd + OP_EqShowBookCmd + OP_EqQuestionnaireCmd + OP_EqGetProbsCmd + OP_EqHearHealCmd + OP_EqChatChannelUpdateCmd + OP_EqWhoChannelQueryReplyCmd + OP_EqAvailWorldChannelsCmd + OP_EqUpdateTargetCmd + OP_EqConsignmentItemsCmd + OP_EqStartBrokerCmd + OP_EqMapExplorationCmd + OP_EqStoreLogCmd + OP_EqSpellMoveToRangeAndRetryCmd + OP_EqUpdatePlayerMailCmd + OP_EqFactionUpdateCmd + OP_EQHearThreatCmd + OP_EqHearSpellNoLandCmd + OP_EQHearDispellCmd + OP_EqTargetItemCmd + + // Arena and game features + OP_ArenaGameTypesMsg + OP_UpdateTitleCmd + OP_UpdatePositionMsg + OP_AttackNotAllowed + OP_AttackAllowed + OP_CancelSpellCast + OP_BadLanguageFilter + OP_DressingRoom + OP_TraitsList + OP_PointOfInterest + OP_AdventureList + OP_CharacterAchievements + OP_RecipeList + OP_BagOptions + OP_AchievementUpdateMsg + OP_PetOptions + OP_BrokerAddBag + OP_CharacterPet + OP_ClearForTakeOffMsg + OP_CharacterCurrency + OP_TradeskillList + OP_RecipeBook + OP_CharacterMerc + OP_AfterInvSpellUpdate + OP_CharacterCreatedDungeons + OP_CharacterHousingList + OP_HouseItemsList + OP_CharacterMounts + OP_LoadCalendarEvents + OP_LoadWelcomeWindow + OP_DungeonMakerItemRequest + OP_SysClient + OP_LFGGroupSearch + OP_MarketPlacePrices + OP_MarketFundsUpdate + OP_MarketAddFundsRequest + OP_ZoneBgInstanceList + OP_UIEvent + OP_Launchpad + OP_Weakness + OP_SavageBarInitMsg + OP_PetOptionsResponse + OP_CurrentPet + OP_JournalQuestStoryline + OP_DailyObjectives + OP_RecipeListUnknown + OP_ClearForLandingMsg + OP_LikeOption + OP_HeritageMsg + OP_OpenCharCust + OP_PaperdollImage + OP_ReadyForTakeOffMsg + OP_EarlyLandingRequestMsg + OP_SubmitCharCust + OP_DietyAbilityWindow +) diff --git a/internal/opcodes/login.go b/internal/opcodes/login.go new file mode 100644 index 0000000..e3ed760 --- /dev/null +++ b/internal/opcodes/login.go @@ -0,0 +1,43 @@ +package opcodes + +// Login server opcodes from login_oplist.h +const ( + OP_LoginRequestMsg = iota + 1 + OP_LoginByNumRequestMsg + OP_WSLoginRequestMsg + OP_ESLoginRequestMsg + OP_LoginReplyMsg + OP_WorldListMsg + OP_WorldStatusChangeMsg + OP_AllWSDescRequestMsg + OP_WSStatusReplyMsg + OP_AllCharactersDescRequestMsg + OP_AllCharactersDescReplyMsg + OP_CreateCharacterRequestMsg + OP_ReskinCharacterRequestMsg + OP_CreateCharacterReplyMsg + OP_WSCreateCharacterRequestMsg + OP_WSCreateCharacterReplyMsg + OP_DeleteCharacterRequestMsg + OP_DeleteCharacterReplyMsg + OP_PlayCharacterRequestMsg + OP_PlayCharacterReplyMsg + OP_ServerPlayCharacterRequestMsg + OP_ServerPlayCharacterReplyMsg + OP_KeymapLoadMsg + OP_KeymapNoneMsg + OP_KeymapDataMsg + OP_KeymapSaveMsg + OP_LSCheckAcctLockMsg + OP_WSAcctLockStatusMsg + OP_LsRequestClientCrashLogMsg + OP_LsClientBaselogReplyMsg + OP_LsClientCrashlogReplyMsg + OP_LsClientAlertlogReplyMsg + OP_LsClientVerifylogReplyMsg + OP_WSServerLockMsg + OP_WSServerHideMsg + OP_LSServerLockMsg + OP_UpdateCharacterSheetMsg + OP_UpdateInventoryMsg +) diff --git a/internal/opcodes/protocol.go b/internal/opcodes/protocol.go new file mode 100644 index 0000000..3e32551 --- /dev/null +++ b/internal/opcodes/protocol.go @@ -0,0 +1,19 @@ +package opcodes + +// Protocol-level opcodes from op_codes.h +const ( + // Core protocol operations + OP_SessionRequest = 0x01 + OP_SessionResponse = 0x02 + OP_Combined = 0x03 + OP_SessionDisconnect = 0x05 + OP_KeepAlive = 0x06 + OP_ServerKeyRequest = 0x07 + OP_SessionStatResponse = 0x08 + OP_Packet = 0x09 + OP_Fragment = 0x0d + OP_OutOfOrderAck = 0x11 + OP_Ack = 0x15 + OP_AppCombined = 0x19 + OP_OutOfSession = 0x1d +) diff --git a/internal/opcodes/server.go b/internal/opcodes/server.go new file mode 100644 index 0000000..02f40de --- /dev/null +++ b/internal/opcodes/server.go @@ -0,0 +1,111 @@ +package opcodes + +// Server communication opcodes from servertalk.h +const ( + // Core server operations + ServerOP_KeepAlive = 0x0001 + ServerOP_ChannelMessage = 0x0002 + ServerOP_SetZone = 0x0003 + ServerOP_ShutdownAll = 0x0004 + ServerOP_ZoneShutdown = 0x0005 + ServerOP_ZoneBootup = 0x0006 + ServerOP_ZoneStatus = 0x0007 + ServerOP_SetConnectInfo = 0x0008 + ServerOP_EmoteMessage = 0x0009 + ServerOP_ClientList = 0x000A + ServerOP_Who = 0x000B + ServerOP_ZonePlayer = 0x000C + ServerOP_KickPlayer = 0x000D + ServerOP_RefreshGuild = 0x000E + ServerOP_GuildKickAll = 0x000F + ServerOP_GuildInvite = 0x0010 + ServerOP_GuildRemove = 0x0011 + ServerOP_GuildPromote = 0x0012 + ServerOP_GuildDemote = 0x0013 + ServerOP_GuildLeader = 0x0014 + ServerOP_GuildGMSet = 0x0015 + ServerOP_GuildGMSetRank = 0x0016 + ServerOP_FlagUpdate = 0x0018 + ServerOP_GMGoto = 0x0019 + ServerOP_MultiLineMsg = 0x001A + ServerOP_Lock = 0x001B + ServerOP_Motd = 0x001C + ServerOP_Uptime = 0x001D + ServerOP_Petition = 0x001E + ServerOP_KillPlayer = 0x001F + ServerOP_UpdateGM = 0x0020 + ServerOP_RezzPlayer = 0x0021 + ServerOP_ZoneReboot = 0x0022 + ServerOP_ZoneToZoneRequest = 0x0023 + ServerOP_AcceptWorldEntrance = 0x0024 + ServerOP_ZAAuth = 0x0025 + ServerOP_ZAAuthFailed = 0x0026 + ServerOP_ZoneIncClient = 0x0027 + ServerOP_ClientListKA = 0x0028 + ServerOP_ChangeWID = 0x0029 + ServerOP_IPLookup = 0x002A + ServerOP_LockZone = 0x002B + ServerOP_ItemStatus = 0x002C + ServerOP_OOCMute = 0x002D + ServerOP_Revoke = 0x002E + ServerOP_GuildJoin = 0x002F + ServerOP_GroupIDReq = 0x0030 + ServerOP_GroupIDReply = 0x0031 + ServerOP_GroupLeave = 0x0032 + ServerOP_RezzPlayerAccept = 0x0033 + ServerOP_SpawnCondition = 0x0034 + ServerOP_SpawnEvent = 0x0035 + + // Login server operations + ServerOP_LSInfo = 0x1000 + ServerOP_LSStatus = 0x1001 + ServerOP_LSClientAuth = 0x1002 + ServerOP_LSFatalError = 0x1003 + ServerOP_SystemwideMessage = 0x1005 + ServerOP_ListWorlds = 0x1006 + ServerOP_PeerConnect = 0x1007 + + // Packet management + ServerOP_EncapPacket = 0x2007 + ServerOP_WorldListUpdate = 0x2008 + ServerOP_WorldListRemove = 0x2009 + ServerOP_TriggerWorldListRefresh = 0x200A + ServerOP_SetWorldTime = 0x200B + ServerOP_GetWorldTime = 0x200C + ServerOP_SyncWorldTime = 0x200E + ServerOP_CharTimeStamp = 0x200F + ServerOP_NameFilterCheck = 0x2011 + ServerOP_BasicCharUpdate = 0x2012 + ServerOP_CharacterCreate = 0x2013 + ServerOP_NameCharUpdate = 0x2014 + ServerOP_GetLatestTables = 0x2015 + ServerOP_GetTableQuery = 0x2016 + ServerOP_GetTableData = 0x2017 + ServerOP_RaceUpdate = 0x2018 + ServerOP_ZoneUpdate = 0x2019 + ServerOP_BugReport = 0x201A + ServerOP_ResetDatabase = 0x201B + ServerOP_ZoneUpdates = 0x201C + ServerOP_LoginEquipment = 0x201D + ServerOP_CharacterPicture = 0x201E + + // Zone management + ServerOP_LSZoneInfo = 0x3001 + ServerOP_LSZoneStart = 0x3002 + ServerOP_LSZoneBoot = 0x3003 + ServerOP_LSZoneShutdown = 0x3004 + ServerOP_LSZoneSleep = 0x3005 + ServerOP_LSPlayerLeftWorld = 0x3006 + ServerOP_LSPlayerJoinWorld = 0x3007 + ServerOP_LSPlayerZoneChange = 0x3008 + + // Update operations + UpdateServerOP_Verified = 0x5090 + UpdateServerOP_DisplayMsg = 0x5091 + UpdateServerOP_Completed = 0x5092 + + // Special operations + ServerOP_UsertoWorldReq = 0xAB00 + ServerOP_UsertoWorldResp = 0xAB01 + ServerOP_WhoAll = 0x0210 +) diff --git a/internal/opcodes/utils.go b/internal/opcodes/utils.go new file mode 100644 index 0000000..1f45b68 --- /dev/null +++ b/internal/opcodes/utils.go @@ -0,0 +1,67 @@ +package opcodes + +// Constants for opcode management +const ( + MAX_EQ_OPCODE = 0xFFFF + APP_OPCODE_SIZE_1 = 1 + APP_OPCODE_SIZE_2 = 2 +) + +// Opcode type definitions +type ( + ProtocolOpcode uint8 + ServerOpcode uint16 + AppOpcode uint16 + EmuOpcode uint16 +) + +// Quick lookup maps for efficient opcode translation +var ( + ProtocolOpcodeNames = map[ProtocolOpcode]string{ + OP_SessionRequest: "OP_SessionRequest", + OP_SessionResponse: "OP_SessionResponse", + OP_Combined: "OP_Combined", + OP_SessionDisconnect: "OP_SessionDisconnect", + OP_KeepAlive: "OP_KeepAlive", + OP_ServerKeyRequest: "OP_ServerKeyRequest", + OP_SessionStatResponse: "OP_SessionStatResponse", + OP_Packet: "OP_Packet", + OP_Fragment: "OP_Fragment", + OP_OutOfOrderAck: "OP_OutOfOrderAck", + OP_Ack: "OP_Ack", + OP_AppCombined: "OP_AppCombined", + OP_OutOfSession: "OP_OutOfSession", + } + + ServerOpcodeNames = map[ServerOpcode]string{ + ServerOP_KeepAlive: "ServerOP_KeepAlive", + ServerOP_ChannelMessage: "ServerOP_ChannelMessage", + ServerOP_SetZone: "ServerOP_SetZone", + ServerOP_ShutdownAll: "ServerOP_ShutdownAll", + // Add more as needed for performance-critical lookups + } +) + +// Helper functions for efficient opcode operations +func IsProtocolOpcode(op uint8) bool { + _, exists := ProtocolOpcodeNames[ProtocolOpcode(op)] + return exists +} + +func IsServerOpcode(op uint16) bool { + return op >= 0x0001 && op <= 0xFFFF +} + +func GetProtocolOpcodeName(op ProtocolOpcode) string { + if name, exists := ProtocolOpcodeNames[op]; exists { + return name + } + return "OP_Unknown" +} + +func GetServerOpcodeName(op ServerOpcode) string { + if name, exists := ServerOpcodeNames[op]; exists { + return name + } + return "ServerOP_Unknown" +} diff --git a/source/LoginServer/EQ2 Login.sln b/source/LoginServer/EQ2 Login.sln deleted file mode 100644 index 48169c7..0000000 --- a/source/LoginServer/EQ2 Login.sln +++ /dev/null @@ -1,25 +0,0 @@ -Microsoft Visual Studio Solution File, Format Version 11.00 -# Visual Studio 2010 -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EQ2 Login", "Login.vcxproj", "{BE2C1914-FCCC-4F65-A7DD-105142B36104}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Win32 = Debug|Win32 - EQ2Login|Win32 = EQ2Login|Win32 - MiniLogin Release|Win32 = MiniLogin Release|Win32 - Release|Win32 = Release|Win32 - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {BE2C1914-FCCC-4F65-A7DD-105142B36104}.Debug|Win32.ActiveCfg = EQ2Login|Win32 - {BE2C1914-FCCC-4F65-A7DD-105142B36104}.Debug|Win32.Build.0 = EQ2Login|Win32 - {BE2C1914-FCCC-4F65-A7DD-105142B36104}.EQ2Login|Win32.ActiveCfg = EQ2Login|Win32 - {BE2C1914-FCCC-4F65-A7DD-105142B36104}.EQ2Login|Win32.Build.0 = EQ2Login|Win32 - {BE2C1914-FCCC-4F65-A7DD-105142B36104}.MiniLogin Release|Win32.ActiveCfg = EQ2Login|Win32 - {BE2C1914-FCCC-4F65-A7DD-105142B36104}.MiniLogin Release|Win32.Build.0 = EQ2Login|Win32 - {BE2C1914-FCCC-4F65-A7DD-105142B36104}.Release|Win32.ActiveCfg = EQ2Login|Win32 - {BE2C1914-FCCC-4F65-A7DD-105142B36104}.Release|Win32.Build.0 = EQ2Login|Win32 - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection -EndGlobal diff --git a/source/LoginServer/EQ2 Login.suo b/source/LoginServer/EQ2 Login.suo deleted file mode 100644 index d090a9e694dfe1f02c09befe49c158489ad874fb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 58880 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 diff --git a/source/LoginServer/Login.dsp b/source/LoginServer/Login.dsp deleted file mode 100644 index cf66e51..0000000 --- a/source/LoginServer/Login.dsp +++ /dev/null @@ -1,447 +0,0 @@ -# Microsoft Developer Studio Project File - Name="Login" - Package Owner=<4> -# Microsoft Developer Studio Generated Build File, Format Version 6.00 -# ** DO NOT EDIT ** - -# TARGTYPE "Win32 (x86) Console Application" 0x0103 - -CFG=Login - Win32 Debug -!MESSAGE This is not a valid makefile. To build this project using NMAKE, -!MESSAGE use the Export Makefile command and run -!MESSAGE -!MESSAGE NMAKE /f "Login.mak". -!MESSAGE -!MESSAGE You can specify a configuration when running NMAKE -!MESSAGE by defining the macro CFG on the command line. For example: -!MESSAGE -!MESSAGE NMAKE /f "Login.mak" CFG="Login - Win32 Debug" -!MESSAGE -!MESSAGE Possible choices for configuration are: -!MESSAGE -!MESSAGE "Login - Win32 Release" (based on "Win32 (x86) Console Application") -!MESSAGE "Login - Win32 Debug" (based on "Win32 (x86) Console Application") -!MESSAGE "Login - Win32 MiniLogin" (based on "Win32 (x86) Console Application") -!MESSAGE "Login - Win32 PublicLogin" (based on "Win32 (x86) Console Application") -!MESSAGE - -# Begin Project -# PROP AllowPerConfigDependencies 0 -# PROP Scc_ProjName "" -# PROP Scc_LocalPath "" -CPP=cl.exe -RSC=rc.exe - -!IF "$(CFG)" == "Login - Win32 Release" - -# PROP BASE Use_MFC 0 -# PROP BASE Use_Debug_Libraries 0 -# PROP BASE Output_Dir "Release" -# PROP BASE Intermediate_Dir "Release" -# PROP BASE Target_Dir "" -# PROP Use_MFC 0 -# PROP Use_Debug_Libraries 0 -# PROP Output_Dir "../Build" -# PROP Intermediate_Dir "../Build/Login" -# PROP Ignore_Export_Lib 0 -# PROP Target_Dir "" -# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c -# ADD CPP /nologo /MT /w /W0 /GX /Zi /O2 /Ob2 /D "LOGINCRYPTO" /D "INVERSEXY" /D _WIN32_WINNT=0x0400 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /c -# ADD BASE RSC /l 0x409 /d "NDEBUG" -# ADD RSC /l 0x409 /d "NDEBUG" -BSC32=bscmake.exe -# ADD BASE BSC32 /nologo -# ADD BSC32 /nologo /o"../Build/Login/Login.bsc" -LINK32=link.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib zlib.lib mysqlclient.lib /nologo /subsystem:console /map:"../Build/Login.map" /debug /machine:I386 -# SUBTRACT LINK32 /pdb:none - -!ELSEIF "$(CFG)" == "Login - Win32 Debug" - -# PROP BASE Use_MFC 0 -# PROP BASE Use_Debug_Libraries 1 -# PROP BASE Output_Dir "Login___Win32_Debug" -# PROP BASE Intermediate_Dir "Login___Win32_Debug" -# PROP BASE Target_Dir "" -# PROP Use_MFC 0 -# PROP Use_Debug_Libraries 1 -# PROP Output_Dir "../build/login/Debug" -# PROP Intermediate_Dir "../build/login/debug" -# PROP Ignore_Export_Lib 0 -# PROP Target_Dir "" -# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c -# ADD CPP /nologo /MTd /Gm /GX /ZI /Od /D "LOGINCRYPTO" /D "INVERSEXY" /D _WIN32_WINNT=0x0400 /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c -# ADD BASE RSC /l 0x409 /d "_DEBUG" -# ADD RSC /l 0x409 /d "_DEBUG" -BSC32=bscmake.exe -# ADD BASE BSC32 /nologo -# ADD BSC32 /nologo -LINK32=link.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib zlib.lib mysqlclient.lib /nologo /subsystem:console /debug /machine:I386 /nodefaultlib:"LIBCMT" /out:"../build/login/Debug/LoginDebug.exe" /pdbtype:sept -# SUBTRACT LINK32 /pdb:none - -!ELSEIF "$(CFG)" == "Login - Win32 MiniLogin" - -# PROP BASE Use_MFC 0 -# PROP BASE Use_Debug_Libraries 0 -# PROP BASE Output_Dir "Login___Win32_MiniLogin" -# PROP BASE Intermediate_Dir "Login___Win32_MiniLogin" -# PROP BASE Ignore_Export_Lib 0 -# PROP BASE Target_Dir "" -# PROP Use_MFC 0 -# PROP Use_Debug_Libraries 0 -# PROP Output_Dir "../Build" -# PROP Intermediate_Dir "../Build/MiniLogin" -# PROP Ignore_Export_Lib 0 -# PROP Target_Dir "" -# ADD BASE CPP /nologo /MT /w /W0 /GX /O2 /Ob2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "BUILD_FOR_WINDOWS" /FR /YX /FD /c -# ADD CPP /nologo /MT /w /W0 /GX /O2 /Ob2 /D _WIN32_WINNT=0x0400 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "MINILOGIN" /FR /YX /FD /c -# ADD BASE RSC /l 0x409 /d "NDEBUG" -# ADD RSC /l 0x409 /d "NDEBUG" -BSC32=bscmake.exe -# ADD BASE BSC32 /nologo /o"../Build/Login/Login.bsc" -# ADD BSC32 /nologo /o"../Build/MiniLogin/Login.bsc" -LINK32=link.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib zlib.lib mysqlclient.lib /nologo /subsystem:console /machine:I386 -# SUBTRACT BASE LINK32 /pdb:none -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib zlib.lib mysqlclient.lib /nologo /subsystem:console /machine:I386 /out:"../Build/MiniLogin.exe" -# SUBTRACT LINK32 /pdb:none - -!ELSEIF "$(CFG)" == "Login - Win32 PublicLogin" - -# PROP BASE Use_MFC 0 -# PROP BASE Use_Debug_Libraries 0 -# PROP BASE Output_Dir "Login___Win32_PublicLogin" -# PROP BASE Intermediate_Dir "Login___Win32_PublicLogin" -# PROP BASE Ignore_Export_Lib 0 -# PROP BASE Target_Dir "" -# PROP Use_MFC 0 -# PROP Use_Debug_Libraries 0 -# PROP Output_Dir "../Build" -# PROP Intermediate_Dir "../Build/PublicLogin" -# PROP Ignore_Export_Lib 0 -# PROP Target_Dir "" -# ADD BASE CPP /nologo /MT /w /W0 /GX /O2 /Ob2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "BUILD_FOR_WINDOWS" /FR /YX /FD /c -# ADD CPP /nologo /MT /w /W0 /GX /O2 /Ob2 /D _WIN32_WINNT=0x0400 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "PUBLICLOGIN" /FR /YX /FD /c -# ADD BASE RSC /l 0x409 /d "NDEBUG" -# ADD RSC /l 0x409 /d "NDEBUG" -BSC32=bscmake.exe -# ADD BASE BSC32 /nologo /o"../Build/Login/Login.bsc" -# ADD BSC32 /nologo /o"../Build/Login/Login.bsc" -LINK32=link.exe -# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib zlib.lib mysqlclient.lib /nologo /subsystem:console /machine:I386 -# SUBTRACT BASE LINK32 /pdb:none -# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib zlib.lib mysqlclient.lib /nologo /subsystem:console /machine:I386 /out:"../Build/PublicLogin.exe" -# SUBTRACT LINK32 /pdb:none - -!ENDIF - -# Begin Target - -# Name "Login - Win32 Release" -# Name "Login - Win32 Debug" -# Name "Login - Win32 MiniLogin" -# Name "Login - Win32 PublicLogin" -# Begin Group "Source Files" - -# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" -# Begin Source File - -SOURCE=.\client.cpp -# End Source File -# Begin Source File - -SOURCE=.\EQCrypto.cpp - -!IF "$(CFG)" == "Login - Win32 Release" - -!ELSEIF "$(CFG)" == "Login - Win32 Debug" - -!ELSEIF "$(CFG)" == "Login - Win32 MiniLogin" - -# PROP Exclude_From_Build 1 - -!ELSEIF "$(CFG)" == "Login - Win32 PublicLogin" - -# PROP Exclude_From_Build 1 - -!ENDIF - -# End Source File -# Begin Source File - -SOURCE=.\logindatabase.cpp - -!IF "$(CFG)" == "Login - Win32 Release" - -!ELSEIF "$(CFG)" == "Login - Win32 Debug" - -!ELSEIF "$(CFG)" == "Login - Win32 MiniLogin" - -# PROP Exclude_From_Build 1 - -!ELSEIF "$(CFG)" == "Login - Win32 PublicLogin" - -!ENDIF - -# End Source File -# Begin Source File - -SOURCE=.\LWorld.cpp -# End Source File -# Begin Source File - -SOURCE=.\net.cpp -# End Source File -# End Group -# Begin Group "Header Files" - -# PROP Default_Filter "h;hpp;hxx;hm;inl" -# Begin Source File - -SOURCE=.\client.h -# End Source File -# Begin Source File - -SOURCE=.\EQCrypto.h -# End Source File -# Begin Source File - -SOURCE=.\login_opcodes.h -# End Source File -# Begin Source File - -SOURCE=.\login_structs.h -# End Source File -# Begin Source File - -SOURCE=.\LWorld.h -# End Source File -# Begin Source File - -SOURCE=.\net.h -# End Source File -# End Group -# Begin Group "Common Source Files" - -# PROP Default_Filter ".cpp" -# Begin Source File - -SOURCE=..\common\crc32.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\database.cpp - -!IF "$(CFG)" == "Login - Win32 Release" - -!ELSEIF "$(CFG)" == "Login - Win32 Debug" - -!ELSEIF "$(CFG)" == "Login - Win32 MiniLogin" - -# PROP Exclude_From_Build 1 - -!ELSEIF "$(CFG)" == "Login - Win32 PublicLogin" - -!ENDIF - -# End Source File -# Begin Source File - -SOURCE=..\common\dbcore.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\DBMemLeak.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\debug.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\EQNetwork.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\md5.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\MiscFunctions.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\Mutex.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\packet_dump.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\packet_functions.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\TCPConnection.cpp -# End Source File -# Begin Source File - -SOURCE=..\common\timer.cpp -# End Source File -# End Group -# Begin Group "Common Header Files" - -# PROP Default_Filter ".h" -# Begin Source File - -SOURCE=..\common\classes.h -# End Source File -# Begin Source File - -SOURCE=..\common\crc32.h -# End Source File -# Begin Source File - -SOURCE=..\common\database.h -# End Source File -# Begin Source File - -SOURCE=..\common\DBMemLeak.h -# End Source File -# Begin Source File - -SOURCE=..\common\debug.h -# End Source File -# Begin Source File - -SOURCE=..\common\deity.h -# End Source File -# Begin Source File - -SOURCE=..\common\eq_opcodes.h -# End Source File -# Begin Source File - -SOURCE=..\common\eq_packet_structs.h -# End Source File -# Begin Source File - -SOURCE=..\common\EQCheckTable.h -# End Source File -# Begin Source File - -SOURCE=..\common\EQFragment.h -# End Source File -# Begin Source File - -SOURCE=..\common\EQNetwork.h -# End Source File -# Begin Source File - -SOURCE=..\common\EQOpcodes.h -# End Source File -# Begin Source File - -SOURCE=..\common\EQPacket.h -# End Source File -# Begin Source File - -SOURCE=..\common\EQPacketManager.h -# End Source File -# Begin Source File - -SOURCE=..\common\errmsg.h -# End Source File -# Begin Source File - -SOURCE=..\common\Guilds.h -# End Source File -# Begin Source File - -SOURCE=..\common\linked_list.h -# End Source File -# Begin Source File - -SOURCE=..\common\md5.h -# End Source File -# Begin Source File - -SOURCE=..\common\MiscFunctions.h -# End Source File -# Begin Source File - -SOURCE=..\common\moremath.h -# End Source File -# Begin Source File - -SOURCE=..\common\Mutex.h -# End Source File -# Begin Source File - -SOURCE=..\common\packet_dump.h -# End Source File -# Begin Source File - -SOURCE=..\common\packet_dump_file.h -# End Source File -# Begin Source File - -SOURCE=..\common\packet_functions.h -# End Source File -# Begin Source File - -SOURCE=..\common\queue.h -# End Source File -# Begin Source File - -SOURCE=..\common\queues.h -# End Source File -# Begin Source File - -SOURCE=..\common\races.h -# End Source File -# Begin Source File - -SOURCE=..\common\Seperator.h -# End Source File -# Begin Source File - -SOURCE=..\common\servertalk.h -# End Source File -# Begin Source File - -SOURCE=..\common\TCPConnection.h -# End Source File -# Begin Source File - -SOURCE=..\common\timer.h -# End Source File -# Begin Source File - -SOURCE=..\common\types.h -# End Source File -# Begin Source File - -SOURCE=..\common\version.h -# End Source File -# End Group -# Begin Group "Text Files" - -# PROP Default_Filter "" -# Begin Source File - -SOURCE=.\Protocol.txt -# End Source File -# Begin Source File - -SOURCE=.\Tables.txt -# End Source File -# Begin Source File - -SOURCE=.\ThanksTo.txt -# End Source File -# End Group -# End Target -# End Project diff --git a/source/LoginServer/Login.dsw b/source/LoginServer/Login.dsw deleted file mode 100644 index 4ed0adf..0000000 --- a/source/LoginServer/Login.dsw +++ /dev/null @@ -1,29 +0,0 @@ -Microsoft Developer Studio Workspace File, Format Version 6.00 -# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! - -############################################################################### - -Project: "Login"=.\Login.dsp - Package Owner=<4> - -Package=<5> -{{{ -}}} - -Package=<4> -{{{ -}}} - -############################################################################### - -Global: - -Package=<5> -{{{ -}}} - -Package=<3> -{{{ -}}} - -############################################################################### - diff --git a/source/LoginServer/Login.vcproj b/source/LoginServer/Login.vcproj deleted file mode 100644 index 7c1f7a6..0000000 --- a/source/LoginServer/Login.vcproj +++ /dev/null @@ -1,542 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/source/LoginServer/Login.vcxproj b/source/LoginServer/Login.vcxproj deleted file mode 100644 index 5622e75..0000000 --- a/source/LoginServer/Login.vcxproj +++ /dev/null @@ -1,154 +0,0 @@ - - - - - EQ2Login - x64 - - - - EQ2Login - {BE2C1914-FCCC-4F65-A7DD-105142B36104} - EQ2 Login - 10.0 - - - - v142 - - - - - - - <_ProjectFileVersion>10.0.30319.1 - - - $(SolutionDir)..\source\depends\mariadb-10.1.19\include;$(SolutionDir)..\source\depends\zlib\include;$(SolutionDir)..\source\depends\recastnavigation\Detour\Include;$(SolutionDir)..\source\depends\boost_1_72_0\;$(SolutionDir)..\source\depends\glm\;$(VC_IncludePath);$(WindowsSDK_IncludePath); - $(SolutionDir)..\source\depends\recastnavigation\RecastDemo\Build\vs2019\lib\Debug;$(SolutionDir)..\source\depends\mariadb-10.1.19\lib\64-debug;$(SolutionDir)..\source\depends\zlib\lib;$(SolutionDir)..\source\depends\boost_1_72_0\lib64-msvc-14.2;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64 - false - $(SolutionDir)loginserver\ - .\$(ProjectName)__Debug64\ - $(ProjectName)__Debug64 - - - - Disabled - AnySuitable - _WIN32_WINNT=0x0400;WIN32;NDEBUG;_CONSOLE;LOGIN; EQ2; EQN_DEBUG;_CRT_SECURE_NO_DEPRECATE;_HAS_STD_BYTE=0 -;%(PreprocessorDefinitions) - EnableFastChecks - MultiThreadedDebug - false - false - - - $(IntDir) - - - 4996;%(DisableSpecificWarnings) - stdcpp17 - - - odbc32.lib;odbccp32.lib;ws2_32.lib;zlib.lib;mysqlclient.lib;DebugUtils.lib;Detour.lib;DetourCrowd.lib;DetourTileCache.lib;Recast.lib;%(AdditionalDependencies) - LIBCMT;LIBC;%(IgnoreSpecificDefaultLibraries) - true - $(IntDir)$(TargetName).pdb - true - true - Default - false - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/source/LoginServer/Login.vcxproj.filters b/source/LoginServer/Login.vcxproj.filters deleted file mode 100644 index fae3865..0000000 --- a/source/LoginServer/Login.vcxproj.filters +++ /dev/null @@ -1,277 +0,0 @@ - - - - - {bfe8d6b0-594f-4b55-9f95-101bbcf4069c} - cpp;c;cxx;rc;def;r;odl;idl;hpj;bat - - - {d65b2760-468c-4206-a19a-48323a50ba5a} - h;hpp;hxx;hm;inl - - - {27b769a5-0972-4e9e-b78c-09ad3341579c} - .cpp - - - {11757e5a-691c-49c9-a627-df027ad58326} - .h - - - {99e7f9f9-abcd-4abf-8200-a4b5a467788c} - - - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - Common Source Files - - - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - World Files - - - World Files - - - World Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - Common Header Files - - - \ No newline at end of file diff --git a/source/LoginServer/Login.vcxproj.user b/source/LoginServer/Login.vcxproj.user deleted file mode 100644 index ace9a86..0000000 --- a/source/LoginServer/Login.vcxproj.user +++ /dev/null @@ -1,3 +0,0 @@ - - - \ No newline at end of file diff --git a/source/LoginServer/Web/LoginWeb.o b/source/LoginServer/Web/LoginWeb.o deleted file mode 100644 index 29c26ff7723387c6e6c2133712dfbe0480bc828a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5302112 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
R5X8$JREVSB0QP~y%@5QM9Q_L<-vj?Wac*3o#3 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

i>MrNC8@%c5!MHKVpew4BmS-YutHWdp&6knr? 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 z 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

CG5$B&Sdax1UeHAR*qHYS!# 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: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

q=s%l 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

+o-CO*H7lQjY~W9NJN^QOIMQ1 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%0DFN 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

n_~&Z;#-ve|rV5GE?n5 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%0D0CCI2#T$-f!=S1_F)?N<4psQkeYFZn-# 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 QpE9jil_-Jo*_+h=KjIo@{r~^~ diff --git a/source/LoginServer/makefile b/source/LoginServer/makefile deleted file mode 100644 index 5071072..0000000 --- a/source/LoginServer/makefile +++ /dev/null @@ -1,32 +0,0 @@ -APP=login -SF= ../common/Log.o ../common/timer.o ../common/packet_dump.o ../common/unix.o \ - ../common/Mutex.o ../common/MiscFunctions.o LoginDatabase.o LoginAccount.o \ - ../common/TCPConnection.o ../common/emu_opcodes.o \ - client.o net.o PacketHeaders.o LWorld.o ../common/md5.o ../common/dbcore.o \ - Web/LoginWeb.o \ - ../common/EQEMuError.o ../common/misc.o ../common/Crypto.o ../common/RC4.o \ - .obj/debug.o .obj/database.o .obj/EQStream.o ../common/xmlParser.o \ - .obj/EQStreamFactory.o .obj/EQPacket.o ../common/CRC16.o ../common/packet_functions.o \ - ../common/Condition.o ../common/opcodemgr.o ../common/PacketStruct.o ../common/ConfigReader.o \ - ../common/DatabaseNew.o ../common/DatabaseResult.o ../common/Web/WebServer.o ../common/JsonParser.o - -CC=g++ -LINKER=gcc -DFLAGS=-DEQ2 -DLOGIN -WFLAGS=-Wall -Wuninitialized -Wwrite-strings -Wcast-qual -Wcomment -Wcast-align -Wno-deprecated -COPTS=$(WFLAGS) -ggdb -march=native -pthread -pipe -DFX -D_GNU_SOURCE -DINVERSEXY $(DFLAGS) -I/usr/include/mariadb -I/usr/local/include/boost -I/usr/include/lua5.4 -std=c++17 -LINKOPTS=-rdynamic -L. -lstdc++ -lm -lz -L/usr/lib/x86_64-linux-gnu -lmariadb -lboost_system -lboost_thread -lboost_filesystem -lssl -lcrypto -lpthread -ldl -all: $(APP) - -$(APP): $(SF) - $(LINKER) $(COPTS) $(OBJS) $^ $(LINKOPTS) -o $@ - -clean: - rm -f $(SF) $(APP) - -%.o: %.cpp - $(CC) -c $(COPTS) $< -o $@ - -.obj/%.o: ../common/%.cpp ../common/%.h - mkdir -p .obj - $(CC) $(COPTS) -c $< -o $@ diff --git a/source/common/CRC16.cpp b/source/common/CRC16.cpp deleted file mode 100644 index f7b43ad..0000000 --- a/source/common/CRC16.cpp +++ /dev/null @@ -1,328 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include - -unsigned long IntArray[]={ -0x00000000, -0x77073096, -0xEE0E612C, -0x990951BA, -0x076DC419, -0x706AF48F, -0xE963A535, -0x9E6495A3, -0x0EDB8832, -0x79DCB8A4, -0xE0D5E91E, -0x97D2D988, -0x09B64C2B, -0x7EB17CBD, -0xE7B82D07, -0x90BF1D91, -0x1DB71064, -0x6AB020F2, -0xF3B97148, -0x84BE41DE, -0x1ADAD47D, -0x6DDDE4EB, -0xF4D4B551, -0x83D385C7, -0x136C9856, -0x646BA8C0, -0xFD62F97A, -0x8A65C9EC, -0x14015C4F, -0x63066CD9, -0xFA0F3D63, -0x8D080DF5, -0x3B6E20C8, -0x4C69105E, -0xD56041E4, -0xA2677172, -0x3C03E4D1, -0x4B04D447, -0xD20D85FD, -0xA50AB56B, -0x35B5A8FA, -0x42B2986C, -0xDBBBC9D6, -0xACBCF940, -0x32D86CE3, -0x45DF5C75, -0xDCD60DCF, -0xABD13D59, -0x26D930AC, -0x51DE003A, -0xC8D75180, -0xBFD06116, -0x21B4F4B5, -0x56B3C423, -0xCFBA9599, -0xB8BDA50F, -0x2802B89E, -0x5F058808, -0xC60CD9B2, -0xB10BE924, -0x2F6F7C87, -0x58684C11, -0xC1611DAB, -0xB6662D3D, -0x76DC4190, -0x01DB7106, -0x98D220BC, -0xEFD5102A, -0x71B18589, -0x06B6B51F, -0x9FBFE4A5, -0xE8B8D433, -0x7807C9A2, -0x0F00F934, -0x9609A88E, -0xE10E9818, -0x7F6A0DBB, -0x086D3D2D, -0x91646C97, -0xE6635C01, -0x6B6B51F4, -0x1C6C6162, -0x856530D8, -0xF262004E, -0x6C0695ED, -0x1B01A57B, -0x8208F4C1, -0xF50FC457, -0x65B0D9C6, -0x12B7E950, -0x8BBEB8EA, -0xFCB9887C, -0x62DD1DDF, -0x15DA2D49, -0x8CD37CF3, -0xFBD44C65, -0x4DB26158, -0x3AB551CE, -0xA3BC0074, -0xD4BB30E2, -0x4ADFA541, -0x3DD895D7, -0xA4D1C46D, -0xD3D6F4FB, -0x4369E96A, -0x346ED9FC, -0xAD678846, -0xDA60B8D0, -0x44042D73, -0x33031DE5, -0xAA0A4C5F, -0xDD0D7CC9, -0x5005713C, -0x270241AA, -0xBE0B1010, -0xC90C2086, -0x5768B525, -0x206F85B3, -0xB966D409, -0xCE61E49F, -0x5EDEF90E, -0x29D9C998, -0xB0D09822, -0xC7D7A8B4, -0x59B33D17, -0x2EB40D81, -0xB7BD5C3B, -0xC0BA6CAD, -0xEDB88320, -0x9ABFB3B6, -0x03B6E20C, -0x74B1D29A, -0xEAD54739, -0x9DD277AF, -0x04DB2615, -0x73DC1683, -0xE3630B12, -0x94643B84, -0x0D6D6A3E, -0x7A6A5AA8, -0xE40ECF0B, -0x9309FF9D, -0x0A00AE27, -0x7D079EB1, -0xF00F9344, -0x8708A3D2, -0x1E01F268, -0x6906C2FE, -0xF762575D, -0x806567CB, -0x196C3671, -0x6E6B06E7, -0xFED41B76, -0x89D32BE0, -0x10DA7A5A, -0x67DD4ACC, -0xF9B9DF6F, -0x8EBEEFF9, -0x17B7BE43, -0x60B08ED5, -0xD6D6A3E8, -0xA1D1937E, -0x38D8C2C4, -0x4FDFF252, -0xD1BB67F1, -0xA6BC5767, -0x3FB506DD, -0x48B2364B, -0xD80D2BDA, -0xAF0A1B4C, -0x36034AF6, -0x41047A60, -0xDF60EFC3, -0xA867DF55, -0x316E8EEF, -0x4669BE79, -0xCB61B38C, -0xBC66831A, -0x256FD2A0, -0x5268E236, -0xCC0C7795, -0xBB0B4703, -0x220216B9, -0x5505262F, -0xC5BA3BBE, -0xB2BD0B28, -0x2BB45A92, -0x5CB36A04, -0xC2D7FFA7, -0xB5D0CF31, -0x2CD99E8B, -0x5BDEAE1D, -0x9B64C2B0, -0xEC63F226, -0x756AA39C, -0x026D930A, -0x9C0906A9, -0xEB0E363F, -0x72076785, -0x05005713, -0x95BF4A82, -0xE2B87A14, -0x7BB12BAE, -0x0CB61B38, -0x92D28E9B, -0xE5D5BE0D, -0x7CDCEFB7, -0x0BDBDF21, -0x86D3D2D4, -0xF1D4E242, -0x68DDB3F8, -0x1FDA836E, -0x81BE16CD, -0xF6B9265B, -0x6FB077E1, -0x18B74777, -0x88085AE6, -0xFF0F6A70, -0x66063BCA, -0x11010B5C, -0x8F659EFF, -0xF862AE69, -0x616BFFD3, -0x166CCF45, -0xA00AE278, -0xD70DD2EE, -0x4E048354, -0x3903B3C2, -0xA7672661, -0xD06016F7, -0x4969474D, -0x3E6E77DB, -0xAED16A4A, -0xD9D65ADC, -0x40DF0B66, -0x37D83BF0, -0xA9BCAE53, -0xDEBB9EC5, -0x47B2CF7F, -0x30B5FFE9, -0xBDBDF21C, -0xCABAC28A, -0x53B39330, -0x24B4A3A6, -0xBAD03605, -0xCDD70693, -0x54DE5729, -0x23D967BF, -0xB3667A2E, -0xC4614AB8, -0x5D681B02, -0x2A6F2B94, -0xB40BBE37, -0xC30C8EA1, -0x5A05DF1B, -0x2D02EF8D, -}; - -unsigned long CRC16(const unsigned char *buf, int size, int key) -{ - unsigned long ecx = key; //mov ecx, [esp+arg_8] - unsigned long eax = ecx; //mov eax, ecx - unsigned long edi; - - eax = ~ eax; //not eax - eax&=0xFF; //and eax, 0FFh - eax=IntArray[eax]; //mov eax, dword_0_10115D38[eax*4] IntArray - eax ^= 0x00FFFFFF; //xor eax, 0FFFFFFh - int edx = ecx; //mov edx, ecx - edx = edx >> 8; //sar edx, 8 - edx = edx ^ eax; //xor edx, eax - eax = eax >> 8; //sar eax, 8 - edx &= 0xFF; //and edx, 0FFh - eax &= 0x00FFFFFF; //and eax, 0FFFFFFh - eax ^= IntArray[edx]; //xor eax, dword_0_10115D38[edx*4] - edx = ecx; //mov edx, ecx - edx = edx >> 0x10; //sar edx, 10h - edx ^= eax; //xor edx, eax - eax = eax >> 8; //sar eax, 8 - edx &= 0xFF; //and edx, 0FFh - int esi = IntArray[edx]; //mov esi, dword_0_10115D38[edx*4] - edx = size; //mov edx, [esp+4+arg_4] - eax &= 0x00FFFFFF; //and eax, 0FFFFFFh - eax ^= esi; //xor eax, esi - ecx = ecx >> 0x18; //sar ecx, 18h - ecx ^= eax; //xor ecx, eax - ecx &= 0xFF; //and ecx, 0FFh - esi = IntArray[ecx]; //mov esi, dword_0_10115D38[ecx*4] - ecx = (int)*buf; //mov ecx, [esp+4+arg_0] - eax = eax >> 8; //sar eax, 8 - eax &= 0x00FFFFFF; //and eax, 0FFFFFFh - eax ^= esi; //xor eax, esi - for(int x = 0; x < size; x++) - { //eax is the crc, ecx is the current part of the buffer - int edx = 0; //xor edx, edx - edx = buf[x] & 0x00FF; //mov dl, [ecx] - - edx ^= eax; //xor edx, eax - eax = eax >> 8; //sar eax, 8 - edx &= 0xFF; //and edx, 0FFh - edi = IntArray[edx]; //mov edi, dword_0_10115D38[edx*4] - eax &= 0x00FFFFFF; //and eax, 0FFFFFFh - eax ^= edi; //xor eax, edi - } - return ~eax; -} diff --git a/source/common/CRC16.h b/source/common/CRC16.h deleted file mode 100644 index 7aacd36..0000000 --- a/source/common/CRC16.h +++ /dev/null @@ -1,25 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef _CRC16_H -#define _CRC16_H - -unsigned long CRC16(const unsigned char *buf, int size, int key); - -#endif diff --git a/source/common/Common_Defines.h b/source/common/Common_Defines.h deleted file mode 100644 index 4600d97..0000000 --- a/source/common/Common_Defines.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#define BASEDIR "./" - -#ifndef DB_INI_FILE - #ifdef LOGIN - #define DB_INI_FILE BASEDIR "login_db.ini" - #else - #define DB_INI_FILE BASEDIR "world_db.ini" - #endif -#endif - -#ifndef MAIN_CONFIG_FILE - #define MAIN_CONFIG_FILE BASEDIR "server_config.json" -#endif \ No newline at end of file diff --git a/source/common/Condition.cpp b/source/common/Condition.cpp deleted file mode 100644 index 348c90a..0000000 --- a/source/common/Condition.cpp +++ /dev/null @@ -1,133 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "debug.h" -#include "Condition.h" - -#ifdef WIN32 -#else -#include -#include -#include -#endif - -#ifdef WIN32 -/* - - Windows does not support condition variables by default. - So we use a simple hack of sleeping in wait() and doing - nothing anywhere else. - - some possible places to look for ways to do this: - http://www.cs.wustl.edu/~schmidt/win32-cv-1.html - - http://sources.redhat.com/pthreads-win32/ - http://sources.redhat.com/cgi-bin/cvsweb.cgi/pthreads/pthread_cond_signal.c?rev=1.7&content-type=text/x-cvsweb-markup&cvsroot=pthreads-win32 - -*/ - -#define CONDITION_HACK_GRANULARITY 4 - - -Condition::Condition() -{ -} - -void Condition::Signal() -{ -} - -void Condition::SignalAll() -{ -} - -void Condition::Wait() -{ - Sleep(CONDITION_HACK_GRANULARITY); -} - -Condition::~Condition() -{ -} - - -#else //!WIN32 - -Condition::Condition() -{ - pthread_cond_init(&cond,NULL); - pthread_mutex_init(&mutex,NULL); -} - -void Condition::Signal() -{ - pthread_mutex_lock(&mutex); - pthread_cond_signal(&cond); - pthread_mutex_unlock(&mutex); -} - -void Condition::SignalAll() -{ - pthread_mutex_lock(&mutex); - pthread_cond_broadcast(&cond); - pthread_mutex_unlock(&mutex); -} - -void Condition::Wait() -{ - pthread_mutex_lock(&mutex); - pthread_cond_wait(&cond,&mutex); - pthread_mutex_unlock(&mutex); -} - -/* -I commented this specifically because I think it might be very -difficult to write a windows counterpart to it, so I would like -to discourage its use until we can confirm that it can be reasonably -implemented on windows. - -bool Condition::TimedWait(unsigned long usec) -{ -struct timeval now; -struct timespec timeout; -int retcode=0; - pthread_mutex_lock(&mutex); - gettimeofday(&now,NULL); - now.tv_usec+=usec; - timeout.tv_sec = now.tv_sec + (now.tv_usec/1000000); - timeout.tv_nsec = (now.tv_usec%1000000) *1000; - //cout << "now=" << now.tv_sec << "."<. -*/ -#ifndef __CONDITION_H -#define __CONDITION_H - -#ifndef WIN32 -#include -#endif - -//Sombody, someday needs to figure out how to implement a condition -//system on windows... - - -class Condition { - private: -#ifndef WIN32 - pthread_cond_t cond; - pthread_mutex_t mutex; -#endif - public: - Condition(); - void Signal(); - void SignalAll(); - void Wait(); -// bool TimedWait(unsigned long usec); - ~Condition(); -}; - -#endif - - diff --git a/source/common/Crypto.cpp b/source/common/Crypto.cpp deleted file mode 100644 index 369390e..0000000 --- a/source/common/Crypto.cpp +++ /dev/null @@ -1,47 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "Crypto.h" -#include -#include "../common/packet_dump.h" - -using namespace std; -void test(); -int64 Crypto::RSADecrypt(uchar* text, int16 size){ - int64 ret = 0; - uchar* buffer = new uchar[8]; - for(int i=7;i>=0;i--) - buffer[7-i] = text[i]; - memcpy(&ret, buffer, 8); - safe_delete_array(buffer); - return ret; -} - -void Crypto::RC4Decrypt(uchar* text, int32 size){ - MCrypto.lock(); - client->Cypher(text, size); - MCrypto.unlock(); -} - -void Crypto::RC4Encrypt(uchar* text, int32 size){ - MCrypto.lock(); - server->Cypher(text, size); - MCrypto.unlock(); -} - diff --git a/source/common/Crypto.h b/source/common/Crypto.h deleted file mode 100644 index d2c478b..0000000 --- a/source/common/Crypto.h +++ /dev/null @@ -1,66 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef _CRYPTO_H -#define _CRYPTO_H -#include -#include -#include "RC4.h" -#include "../common/types.h" - -using namespace std; -class Crypto { -public: - ~Crypto(){ safe_delete(client); safe_delete(server); } - Crypto() { rc4_key = 0; encrypted = false; client = 0; server = 0; }; - - static int64 RSADecrypt(uchar* text, int16 size); - void RC4Encrypt(uchar* text, int32 size); - void RC4Decrypt(uchar* text, int32 size); - int64 getRC4Key() { return rc4_key; } - void setRC4Key(int64 key) { - rc4_key = key; - if(key > 0){ - encrypted = true; - client = new RC4(~key); - server = new RC4(key); - uchar temp[20]; - client->Cypher(temp, 20); - server->Cypher(temp, 20); - } - else{ - encrypted = false; - safe_delete(client); - safe_delete(server); - } - } - bool isEncrypted(){ return encrypted; } - void setEncrypted(bool in_val){ encrypted = in_val; } - - -private: - RC4* server; - RC4* client; - bool encrypted; - int64 rc4_key; - mutex MCrypto; -}; - -#endif - diff --git a/source/common/DataBuffer.h b/source/common/DataBuffer.h deleted file mode 100644 index f40486d..0000000 --- a/source/common/DataBuffer.h +++ /dev/null @@ -1,207 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef __EQ2_DATABUFFER_ -#define __EQ2_DATABUFFER_ -#include -#include "../common/types.h" -#include "../common/EQPacket.h" -#include "../common/EQ2_Common_Structs.h" - -#ifdef WORLD - #include "../WorldServer/SpawnLists.h" -#endif - -using namespace std; - -class DataBuffer{ -public: - bool changed; - uchar* getData(){ return (uchar*)buffer.c_str(); } - int32 getDataSize(){ return buffer.length(); } - string* getDataString(){ return &buffer; } - void CreateEQ2Color(EQ2_Color& color){ - CreateEQ2Color(&color); - } - uchar* GetLoadBuffer(){ - return load_buffer; - } - int32 GetLoadPos(){ - return load_pos; - } - int32 GetLoadLen(){ - return load_len; - } - void SetLoadPos(int32 new_pos){ - load_pos = new_pos; - } - void CreateEQ2Color(EQ2_Color* color){ - int8 rgb[3]; - float* tmp = 0; - for(int i=0;i<3;i++){ - tmp = (float*)(load_buffer + load_pos); - rgb[i] = (int8)((*tmp)*255); - load_pos += sizeof(float); - } - color->red = rgb[0]; - color->green = rgb[1]; - color->blue = rgb[2]; - } - - template void MakeEQ2_Int8(Type& output){ - MakeEQ2_Int8(&output); - } - template void MakeEQ2_Int8(Type* output){ - float* tmp = (float*)(load_buffer + load_pos); - if(*tmp < 0) - *tmp *= -1; - sint8 result = (sint8)((*tmp)*100); - memcpy(output, &result, sizeof(sint8)); - load_pos += sizeof(float); - } - void InitializeGetData(){ - get_buffer = (uchar*)buffer.c_str(); - get_len = buffer.length(); - get_pos = 0; - } - void InitializeLoadData(uchar* input, int32 size){ - buffer = string((char*)input, size); - load_buffer = (uchar*)buffer.c_str(); - load_len = size; - load_pos = 0; - } - template void LoadDataString(String& output){ - LoadDataString(&output); - } - template void LoadDataString(String* output){ - if((sizeof(output->size) + load_pos) <= load_len){ - memcpy(&output->size, load_buffer + load_pos, sizeof(output->size)); - load_pos += sizeof(output->size); - } - if((output->size + load_pos) <= load_len){ - output->data = string((char*)(load_buffer + load_pos), output->size); - load_pos += output->size; - } - } - template void LoadData(Type& output){ - LoadData(&output); - } - template void LoadData(Type* output, int32 array_size){ - if(array_size<=1){ - LoadData(output); - } - else{ - for(int32 i=0;i void LoadData(Type* output){ - if((sizeof(Type) + load_pos) <= load_len){ - memcpy(output, load_buffer + load_pos, sizeof(Type)); - load_pos += sizeof(Type); - } - } - template void LoadData(Type& output, int32 array_size){ - LoadData(&output, array_size); - } - void LoadSkip(int8 bytes){ - load_pos += bytes; - } - template void LoadSkip(Type& skip){ - LoadSkip(&skip); - } - template void LoadSkip(Type* skip){ - load_pos += sizeof(Type); - } - template void GetData(Type* output){ - if((sizeof(Type) + get_pos) <= get_len){ - *output = (Type*)get_buffer; - get_pos += sizeof(output); - } - } - void AddZeros(int16 num){ - int8* data = new int8[num]; - memset(data, 0, num); - AddData(*data); - safe_delete_array(data); - } - template void StructAddData(Type input, int16 size, string* datastring){ - if(datastring) - datastring->append((char*)&input, size); - else - buffer.append((char*)&input, size); - } - template void StructAddData(Type input, int32 array_size, int16 size, string* datastring){ - if(array_size>0){ - for(int32 i=0;i void AddData(Type input, string* datastring = 0){ - if(!datastring) - datastring = &buffer; - datastring->append((char*)&input, sizeof(input)); - } - template void AddData(Type input, int32 array_size, string* datastring = 0){ - if(array_size>0){ - for(int32 i=0;i void AddDataString(String* input, string* datastring = 0){ - AddDataString(*input, datastring); - } - template void AddDataString(String input, string* datastring = 0){ - input.size = input.data.length(); - if(!datastring) - datastring = &buffer; - datastring->append((char*)&input.size, sizeof(input.size)); - datastring->append(input.data); - } - void AddCharArray(char* array, string* datastring = 0){ - if(!datastring) - datastring = &buffer; - datastring->append(array); - } - void AddCharArray(char* array, int16 size, string* datastring = 0){ - if(!datastring) - datastring = &buffer; - datastring->append(array, size); - } - void AddData(string data, string* datastring = 0){ - if(!datastring) - datastring = &buffer; - datastring->append(data); - } - void Clear() { buffer.clear(); } -private: - string buffer; - uchar* get_buffer; - uchar* load_buffer; - int32 get_len; - int32 get_pos; - int32 load_len; - int32 load_pos; -}; -#endif - diff --git a/source/common/DatabaseNew.cpp b/source/common/DatabaseNew.cpp deleted file mode 100644 index e1e2450..0000000 --- a/source/common/DatabaseNew.cpp +++ /dev/null @@ -1,422 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include -#include -#include -#include -#include "Log.h" -#include "DatabaseNew.h" -#include - -//increase this if large queries are being run frequently to make less calls to malloc() -#define QUERY_INITIAL_SIZE 512 - -#if defined WORLD -#define DB_INI "world_db.ini" -#elif defined LOGIN -#define DB_INI "login_db.ini" -#elif defined PARSER -#define DB_INI "parser_db.ini" -#endif - -DatabaseNew::DatabaseNew() { - mysql_init(&mysql); - int timeout = 10; - mysql_options(&mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout); - MMysql.SetName("DatabaseNew::mysql"); -} - -DatabaseNew::~DatabaseNew() { - mysql_close(&mysql); -#if MYSQL_VERSION_ID >= 50003 - mysql_library_end(); -#else - mysql_server_end(); -#endif -} - -bool DatabaseNew::Connect() { - char line[256], *key, *val; - char host[256], user[64], password[64], database[64], port[64]; - bool found_section = false; - FILE *f; - - if ((f = fopen(DB_INI, "r")) == NULL) { - LogWrite(DATABASE__ERROR, 0, "Database", "Unable to read %s\n", DB_INI); - return false; - } - - memset(host, 0, sizeof(host)); - memset(user, 0, sizeof(user)); - memset(password, 0, sizeof(password)); - memset(database, 0, sizeof(database)); - memset(port, 0, sizeof(port)); - - while (fgets(line, sizeof(line), f) != NULL) { - if (line[0] == '#' || line[0] == '\n' || line[0] == '\r') - continue; - - if (!found_section) { - if (strncasecmp(line, "[Database]", 10) == 0) - found_section = true; - } - else { - if ((key = strtok(line, "=")) != NULL) { - if ((val = strtok(NULL, "\r\n")) != NULL) { - if (strncasecmp(line, "host", 4) == 0) - strncpy(host, val, sizeof(host) - 1); - else if (strncasecmp(line, "user", 4) == 0) - strncpy(user, val, sizeof(user) - 1); - else if (strncasecmp(line, "password", 8) == 0) - strncpy(password, val, sizeof(password) - 1); - else if (strncasecmp(line, "database", 8) == 0) - strncpy(database, val, sizeof(database) - 1); - else if (strncasecmp(line, "port", 4) == 0) - strncpy(port, val, sizeof(port) - 1); - } - } - } - } - - fclose(f); - - if (host[0] == '\0') { - LogWrite(DATABASE__ERROR, 0, "Database", "Unknown 'host' in '%s'\n", DB_INI); - return false; - } - if (user[0] == '\0') { - LogWrite(DATABASE__ERROR, 0, "Database", "Unknown 'user' in '%s'\n", DB_INI); - return false; - } - if (password[0] == '\0') { - LogWrite(DATABASE__ERROR, 0, "Database", "Unknown 'password' in '%s'\n", DB_INI); - return false; - } - if (database[0] == '\0') { - LogWrite(DATABASE__ERROR, 0, "Database", "Unknown 'database' in '%s'\n", DB_INI); - return false; - } - - unsigned int portnum = atoul(port); - return Connect(host, user, password, database, portnum); -} - -bool DatabaseNew::Connect(const char *host, const char *user, const char *password, const char *database, unsigned int port) { - if (mysql_real_connect(&mysql, host, user, password, database, port, NULL, 0) == NULL) { - LogWrite(DATABASE__ERROR, 0, "Database", "Unable to connect to MySQL server at %s:%u: %s\n", host, port, mysql_error(&mysql)); - return false; - } - - return true; -} - -bool DatabaseNew::Query(const char *query, ...) { - char *buf; - size_t size = QUERY_INITIAL_SIZE; - int num_chars; - va_list args; - bool ret = true; - - MMysql.writelock(__FUNCTION__, __LINE__); - while (true) { - if ((buf = (char *)malloc(size)) == NULL) { - LogWrite(DATABASE__ERROR, 0, "Database", "Out of memory trying to allocate database query of %u bytes\n", size); - MMysql.releasewritelock(__FUNCTION__, __LINE__); - return false; - } - - va_start(args, query); - num_chars = vsnprintf(buf, size, query, args); - va_end(args); - - if (num_chars > -1 && (size_t)num_chars < size) - break; - - if (num_chars > -1) - size = num_chars + 1; - else - size *= 2; - - free(buf); - } - - if (mysql_real_query(&mysql, buf, num_chars) != 0) { - - if (mysql_errno(&mysql) == CR_SERVER_LOST || mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) { - LogWrite(DATABASE__ERROR, 0, "Database", "Lost connection, attempting to recover and retry query..."); - Connect(); - - // retry attempt of previous query (1 try and we give up) - if (mysql_real_query(&mysql, buf, num_chars) != 0) { - ret = false; - } - } - else if (!IsIgnoredErrno(mysql_errno(&mysql))) { - LogWrite(DATABASE__ERROR, 0, "Database", "Error %i running MySQL query: %s\n%s\n", mysql_errno(&mysql), mysql_error(&mysql), buf); - ret = false; - } - } - free(buf); - - MMysql.releasewritelock(__FUNCTION__, __LINE__); - return ret; -} - -bool DatabaseNew::Select(DatabaseResult *result, const char *query, ...) { - char *buf; - size_t size = QUERY_INITIAL_SIZE; - int num_chars; - va_list args; - MYSQL_RES *res; - bool ret = true; - - MMysql.writelock(__FUNCTION__, __LINE__); - while (true) { - if ((buf = (char *)malloc(size)) == NULL) { - LogWrite(DATABASE__ERROR, 0, "Database", "Out of memory trying to allocate database query of %u bytes\n", size); - MMysql.releasewritelock(__FUNCTION__, __LINE__); - return false; - } - - va_start(args, query); - num_chars = vsnprintf(buf, size, query, args); - va_end(args); - - if (num_chars > -1 && (size_t)num_chars < size) - break; - - if (num_chars > -1) - size = num_chars + 1; - else - size *= 2; - - free(buf); - } - - if (mysql_real_query(&mysql, buf, (unsigned long)num_chars) != 0) { - - if (mysql_errno(&mysql) == CR_SERVER_LOST || mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) { - LogWrite(DATABASE__ERROR, 0, "Database", "Lost connection, attempting to recover and retry query..."); - - mysql_close(&mysql); - Connect(); - - // retry attempt of previous query (1 try and we give up) - if (mysql_real_query(&mysql, buf, (unsigned long)num_chars) != 0) { - ret = false; - } - } - else if (!IsIgnoredErrno(mysql_errno(&mysql))) { - LogWrite(DATABASE__ERROR, 0, "Database", "Error %i running MySQL query: %s\n%s\n", mysql_errno(&mysql), mysql_error(&mysql), buf); - ret = false; - } - } - - if (ret && !IsIgnoredErrno(mysql_errno(&mysql))) { - res = mysql_store_result(&mysql); - - if (res != NULL) - { - // Grab number of rows and number of fields from the query - uint8 num_rows = mysql_affected_rows(&mysql); - uint8 num_fields = mysql_field_count(&mysql); - - ret = result->StoreResult(res, num_fields, num_rows); - } - else { - LogWrite(DATABASE__ERROR, 0, "Database", "Error storing MySql query result (%d): %s\n%s", mysql_errno(&mysql), mysql_error(&mysql), buf); - ret = false; - } - } - - free(buf); - - MMysql.releasewritelock(__FUNCTION__, __LINE__); - return ret; -} - -int32 DatabaseNew::LastInsertID() -{ - return (int32)mysql_insert_id(&mysql); -} - -long DatabaseNew::AffectedRows() -{ - return mysql_affected_rows(&mysql); -} - -char * DatabaseNew::Escape(const char *str, size_t len) { - char *buf = (char *)malloc(len * 2 + 1); - - if (buf == NULL) { - LogWrite(DATABASE__ERROR, 0, "Database", "Out of memory trying to allocate %u bytes in %s:%u\n", len * 2 + 1, __FUNCTION__, __LINE__); - return NULL; - } - - mysql_real_escape_string(&mysql, buf, str, len); - return buf; -} - -char * DatabaseNew::Escape(const char *str) { - return Escape(str, strlen(str)); -} - -string DatabaseNew::EscapeStr(const char *str, size_t len) { - char *buf = (char *)malloc(len * 2 + 1); - string ret; - - if (buf == NULL) { - LogWrite(DATABASE__ERROR, 0, "Database", "Out of memory trying to allocate %u bytes in %s:%u\n", len * 2 + 1, __FUNCTION__, __LINE__); - return NULL; - } - - mysql_real_escape_string(&mysql, buf, str, len); - ret.append(buf); - free(buf); - - return ret; -} - -string DatabaseNew::EscapeStr(const char *str) { - return EscapeStr(str, strlen(str)); -} - -string DatabaseNew::EscapeStr(string str) { - return EscapeStr(str.c_str(), str.length()); -} - -bool DatabaseNew::QueriesFromFile(const char * file) { - bool success = true; - long size; - char *buf; - int ret; - MYSQL_RES *res; - FILE *f; - - f = fopen(file, "rb"); - if (f == NULL) { - LogWrite(DATABASE__ERROR, 0, "Database", "Unable to open '%s' for reading: %s", file, strerror(errno)); - return false; - } - - fseek(f, 0, SEEK_END); - size = ftell(f); - fseek(f, 0, SEEK_SET); - - buf = (char *)malloc(size + 1); - if (buf == NULL) { - fclose(f); - LogWrite(DATABASE__ERROR, 0, "Database", "Out of memory trying to allocate %u bytes in %s:%u\n", size + 1, __FUNCTION__, __LINE__); - return false; - } - - if (fread(buf, sizeof(*buf), size, f) != (size_t)size) { - LogWrite(DATABASE__ERROR, 0, "Database", "Failed to read from '%s': %s", file, strerror(errno)); - fclose(f); - free(buf); - return false; - } - - buf[size] = '\0'; - fclose(f); - - mysql_set_server_option(&mysql, MYSQL_OPTION_MULTI_STATEMENTS_ON); - ret = mysql_real_query(&mysql, buf, size); - free(buf); - - if (ret != 0) { - LogWrite(DATABASE__ERROR, 0, "Database", "Error running MySQL queries from file '%s' (%d): %s", file, mysql_errno(&mysql), mysql_error(&mysql)); - success = false; - } - else { - //all results must be processed - do { - res = mysql_store_result(&mysql); - if (res != NULL) - mysql_free_result(res); - ret = mysql_next_result(&mysql); - - if (ret > 0) { - LogWrite(DATABASE__ERROR, 0, "Database", "Error running MySQL queries from file '%s' (%d): %s", file, mysql_errno(&mysql), mysql_error(&mysql)); - success = false; - } - - } while (ret == 0); - } - mysql_set_server_option(&mysql, MYSQL_OPTION_MULTI_STATEMENTS_OFF); - - return success; -} - -void DatabaseNew::SetIgnoredErrno(unsigned int db_errno) { - vector::iterator itr; - - for (itr = ignored_errnos.begin(); itr != ignored_errnos.end(); itr++) { - if ((*itr) == db_errno) - return; - } - - ignored_errnos.push_back(db_errno); -} - -void DatabaseNew::RemoveIgnoredErrno(unsigned int db_errno) { - vector::iterator itr; - - for (itr = ignored_errnos.begin(); itr != ignored_errnos.end(); itr++) { - if ((*itr) == db_errno) { - ignored_errnos.erase(itr); - break; - } - } -} - -bool DatabaseNew::IsIgnoredErrno(unsigned int db_errno) { - vector::iterator itr; - - for (itr = ignored_errnos.begin(); itr != ignored_errnos.end(); itr++) { - if ((*itr) == db_errno) - return true; - } - - return false; -} - -// Sends the MySQL server a keepalive -void DatabaseNew::PingNewDB() { - MMysql.writelock(__FUNCTION__, __LINE__); - mysql_ping(&mysql); - - int32* errnum = new int32; - *errnum = mysql_errno(&mysql); - - switch (*errnum) - { - case CR_COMMANDS_OUT_OF_SYNC: - case CR_SERVER_GONE_ERROR: - case CR_UNKNOWN_ERROR: - { - LogWrite(DATABASE__ERROR, 0, "Database", "[Database] We lost connection to the database., errno: %i", errno); - break; - } - } - - safe_delete(errnum); - MMysql.releasewritelock(__FUNCTION__, __LINE__); -} \ No newline at end of file diff --git a/source/common/DatabaseNew.h b/source/common/DatabaseNew.h deleted file mode 100644 index 2e2e002..0000000 --- a/source/common/DatabaseNew.h +++ /dev/null @@ -1,48 +0,0 @@ -#ifndef COMMON_DATABASE_H_ -#define COMMON_DATABASE_H_ - -#include -#include "DatabaseResult.h" - -using namespace std; - -class DatabaseNew { -public: - DatabaseNew(); - virtual ~DatabaseNew(); - - unsigned int GetError() {return mysql_errno(&mysql);} - const char * GetErrorMsg() {return mysql_error(&mysql);} - - bool Connect(); - bool Connect(const char *host, const char *user, const char *password, const char *database, unsigned int port = 3306); - - bool Query(const char *query, ...); - bool Select(DatabaseResult *result, const char *query, ...); - - int32 LastInsertID(); - long AffectedRows(); - - //these two must free() the return char* after it's used in a query - char * Escape(const char *str, size_t len); - char * Escape(const char *str); - - //does not need free() - string EscapeStr(const char *str, size_t len); - string EscapeStr(const char *str); - string EscapeStr(string str); - - bool QueriesFromFile(const char *file); - void SetIgnoredErrno(unsigned int db_errno); - void RemoveIgnoredErrno(unsigned int db_errno); - bool IsIgnoredErrno(unsigned int db_errno); - - void PingNewDB(); -private: - MYSQL mysql; - Mutex MMysql; - - vector ignored_errnos; -}; - -#endif diff --git a/source/common/DatabaseResult.cpp b/source/common/DatabaseResult.cpp deleted file mode 100644 index 05df1a8..0000000 --- a/source/common/DatabaseResult.cpp +++ /dev/null @@ -1,234 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include -#include -#include "Log.h" -#include "DatabaseResult.h" - -//enforced by MySQL...couldn't find a #define in their headers though -#define FIELD_NAME_MAX 64 - -//return this instead of NULL for certain functions to prevent crashes from coding errors -static const char *empty_str = ""; - -DatabaseResult::DatabaseResult(): field_map(), result(0), num_fields(0), row(0) { -} - -DatabaseResult::~DatabaseResult() { - unsigned int i; - - if (result != NULL) - mysql_free_result(result); - - if (field_map.size()) { - field_map.clear(); - } -} - -bool DatabaseResult::StoreResult(MYSQL_RES* res, uint8 field_count, uint8 row_count) { - - //clear any previously stored result - if (result != NULL) - mysql_free_result(result); - - //clear any field names from a previous result - if (field_map.size()) { - field_map.clear(); - } - - result = res; - num_rows = row_count; - num_fields = field_count; - - // No rows or fields then we don't care - if (!num_rows || !num_fields) { - mysql_free_result(res); - result = NULL; - return false; - } - - - const MYSQL_FIELD* fields = mysql_fetch_fields(result); - - for (uint8 i = 0; i < num_fields; ++i) { - field_map.emplace(std::make_pair(std::string_view(fields[i].name), i)); - } - - return true; -} - -const char * DatabaseResult::GetFieldValue(unsigned int index) { - if (index >= num_fields) { - LogWrite(DATABASE__ERROR, 0, "Database Result", "Attempt to access field at index %u but there %s only %u field%s", index, num_fields == 1 ? "is" : "are", num_fields, num_fields == 1 ? "" : "s"); - return NULL; - } - - return row[index]; -} - -const char * DatabaseResult::GetFieldValueStr(const char *field_name) { - const auto& map_iterator = field_map.find(std::string_view(field_name)); - if (map_iterator != field_map.end()) { - return row[map_iterator->second]; - } - - LogWrite(DATABASE__ERROR, 0, "Database Result", "Unknown field name '%s'", field_name); - return NULL; -} - -bool DatabaseResult::Next() { - return (result != NULL && (row = mysql_fetch_row(result)) != NULL); -} - -bool DatabaseResult::IsNull(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL; -} - -bool DatabaseResult::IsNullStr(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL; -} - -int8 DatabaseResult::GetInt8(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? 0 : atoi(value); -} - -int8 DatabaseResult::GetInt8Str(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? 0 : atoi(value); -} - -sint8 DatabaseResult::GetSInt8(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? 0 : atoi(value); -} - -sint8 DatabaseResult::GetSInt8Str(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? 0 : atoi(value); -} - -int16 DatabaseResult::GetInt16(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? 0 : atoi(value); -} - -int16 DatabaseResult::GetInt16Str(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? 0 : atoi(value); -} - -sint16 DatabaseResult::GetSInt16(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? 0 : atoi(value); -} - -sint16 DatabaseResult::GetSInt16Str(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? 0 : atoi(value); -} - -int32 DatabaseResult::GetInt32(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? 0U : strtoul(value, NULL, 10); -} - -int32 DatabaseResult::GetInt32Str(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? 0U : strtoul(value, NULL, 10); -} - -sint32 DatabaseResult::GetSInt32(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? 0 : atoi(value); -} - -sint32 DatabaseResult::GetSInt32Str(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? 0 : atoi(value); -} - -uint64 DatabaseResult::GetInt64(unsigned int index) { - const char *value = GetFieldValue(index); -#ifdef _WIN32 - return value == NULL ? 0UL : _strtoui64(value, NULL, 10); -#else - return value == NULL ? 0UL : strtoull(value, NULL, 10); -#endif -} - -uint64 DatabaseResult::GetInt64Str(const char *field_name) { - const char *value = GetFieldValueStr(field_name); -#ifdef _WIN32 - return value == NULL ? 0UL : _strtoui64(value, NULL, 10); -#else - return value == NULL ? 0UL : strtoull(value, NULL, 10); -#endif -} - -sint64 DatabaseResult::GetSInt64(unsigned int index) { - const char *value = GetFieldValue(index); -#ifdef _WIN32 - return value == NULL ? 0L : _strtoi64(value, NULL, 10); -#else - return value == NULL ? 0L : strtoll(value, NULL, 10); -#endif -} - -sint64 DatabaseResult::GetSInt64Str(const char *field_name) { - const char *value = GetFieldValueStr(field_name); -#ifdef _WIN32 - return value == NULL ? 0L : _strtoi64(value, NULL, 10); -#else - return value == NULL ? 0L : strtoll(value, NULL, 10); -#endif -} - -float DatabaseResult::GetFloat(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? 0.0F : atof(value); -} - -float DatabaseResult::GetFloatStr(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? 0.0F : atof(value); -} - -char DatabaseResult::GetChar(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? '\0' : value[0]; -} - -char DatabaseResult::GetCharStr(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? '\0' : value[0]; -} - -const char * DatabaseResult::GetString(unsigned int index) { - const char *value = GetFieldValue(index); - return value == NULL ? empty_str : value; -} - -const char * DatabaseResult::GetStringStr(const char *field_name) { - const char *value = GetFieldValueStr(field_name); - return value == NULL ? empty_str : value; -} diff --git a/source/common/DatabaseResult.h b/source/common/DatabaseResult.h deleted file mode 100644 index 36b3c3e..0000000 --- a/source/common/DatabaseResult.h +++ /dev/null @@ -1,57 +0,0 @@ -#ifndef COMMON_DATABASERESULT_H_ -#define COMMON_DATABASERESULT_H_ - -#include "types.h" -#ifdef _WIN32 -#include //#include when we/if we go to winsock2 :/ -#endif -#include -#include - -class DatabaseResult { -public: - DatabaseResult(); - virtual ~DatabaseResult(); - - bool StoreResult(MYSQL_RES* result, uint8 field_count, uint8 row_count); - bool Next(); - - bool IsNull(unsigned int index); - bool IsNullStr(const char *field_name); - int8 GetInt8(unsigned int index); - int8 GetInt8Str(const char *field_name); - sint8 GetSInt8(unsigned int index); - sint8 GetSInt8Str(const char *field_name); - int16 GetInt16(unsigned int index); - int16 GetInt16Str(const char *field_name); - sint16 GetSInt16(unsigned int index); - sint16 GetSInt16Str(const char *field_name); - int32 GetInt32(unsigned int index); - int32 GetInt32Str(const char *field_name); - sint32 GetSInt32(unsigned int index); - sint32 GetSInt32Str(const char *field_name); - int64 GetInt64(unsigned int index); - int64 GetInt64Str(const char *field_name); - sint64 GetSInt64(unsigned int index); - sint64 GetSInt64Str(const char *field_name); - float GetFloat(unsigned int index); - float GetFloatStr(const char *field_name); - char GetChar(unsigned int index); - char GetCharStr(const char *field_name); - const char * GetString(unsigned int index); - const char * GetStringStr(const char *field_name); - - const unsigned int GetNumRows() { return num_rows; } - - const char * GetFieldValue(unsigned int index); - const char * GetFieldValueStr(const char *field_name); -private: - MYSQL_RES *result; - MYSQL_ROW row; - unsigned int num_rows; - unsigned int num_fields; - - std::map field_map; -}; - -#endif diff --git a/source/common/JsonParser.cpp b/source/common/JsonParser.cpp deleted file mode 100644 index cca065a..0000000 --- a/source/common/JsonParser.cpp +++ /dev/null @@ -1,97 +0,0 @@ -#include "JsonParser.h" - -JsonParser::JsonParser(const std::string &filename) { - is_loaded = false; - try { - boost::property_tree::read_json(filename, pt); - parseTree(pt, ""); - is_loaded = true; - } catch (const boost::property_tree::json_parser_error &e) { - std::cerr << "Error reading JSON file: " << e.what() << std::endl; - } -} - -bool JsonParser::convertStringToUnsignedChar(const std::string& str, unsigned char& result) { - unsigned long ul; - try { - ul = std::stoul(str); - } catch (const std::invalid_argument&) { - return false; // Not a valid number - } catch (const std::out_of_range&) { - return false; // Number is too large for unsigned long - } - - if (ul > std::numeric_limits::max()) { - return false; // Number is too large for unsigned short - } - - result = static_cast(ul); - return true; -} - -bool JsonParser::convertStringToUnsignedShort(const std::string& str, unsigned short& result) { - unsigned long ul; - try { - ul = std::stoul(str); - } catch (const std::invalid_argument&) { - return false; // Not a valid number - } catch (const std::out_of_range&) { - return false; // Number is too large for unsigned long - } - - if (ul > std::numeric_limits::max()) { - return false; // Number is too large for unsigned short - } - - result = static_cast(ul); - return true; -} - -bool JsonParser::convertStringToUnsignedInt(const std::string& str, unsigned int& result) { - unsigned long ul; - try { - ul = std::stoul(str); - } catch (const std::invalid_argument&) { - return false; // Not a valid number - } catch (const std::out_of_range&) { - return false; // Number is too large for unsigned long - } - - if (ul > std::numeric_limits::max()) { - return false; // Number is too large for unsigned short - } - - result = static_cast(ul); - return true; -} - -bool JsonParser::convertStringToUnsignedLong(const std::string& str, unsigned long& result) { - unsigned long ul; - try { - ul = std::stoul(str); - } catch (const std::invalid_argument&) { - return false; // Not a valid number - } catch (const std::out_of_range&) { - return false; // Number is too large for unsigned long - } - - if (ul > std::numeric_limits::max()) { - return false; // Number is too large for unsigned short - } - - result = ul; - return true; -} - -void JsonParser::parseTree(const boost::property_tree::ptree &tree, const std::string &path) { - for (const auto &node : tree) { - std::string currentPath = path.empty() ? node.first : path + "." + node.first; - if (node.second.empty()) { - std::string name = currentPath; - boost::algorithm::to_lower(name); - values[name] = node.second.get_value(); - } else { - parseTree(node.second, currentPath); - } - } -} \ No newline at end of file diff --git a/source/common/JsonParser.h b/source/common/JsonParser.h deleted file mode 100644 index f92b07d..0000000 --- a/source/common/JsonParser.h +++ /dev/null @@ -1,33 +0,0 @@ - -#include -#include -#include -#include -#include -#include -#include - -class JsonParser { -public: - JsonParser(const std::string &filename); - - std::string getValue(const std::string &path) const { - auto it = values.find(path); - if (it != values.end()) { - return it->second; - } - return ""; - } - - static bool convertStringToUnsignedChar(const std::string& str, unsigned char& result); - static bool convertStringToUnsignedShort(const std::string& str, unsigned short& result); - static bool convertStringToUnsignedInt(const std::string& str, unsigned int& result); - static bool convertStringToUnsignedLong(const std::string& str, unsigned long& result); - bool IsLoaded() { return is_loaded; } -private: - boost::property_tree::ptree pt; - std::map values; - - void parseTree(const boost::property_tree::ptree &tree, const std::string &path); - bool is_loaded; -}; diff --git a/source/common/Mutex.cpp b/source/common/Mutex.cpp deleted file mode 100644 index 732e451..0000000 --- a/source/common/Mutex.cpp +++ /dev/null @@ -1,361 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "../common/Log.h" -#include "../common/debug.h" -#include "../common/Mutex.h" - -Mutex::Mutex() { - readers = 0; - mlocked = false; - writing = false; - name = ""; -#ifdef DEBUG - stack.clear(); -#endif - //CSLock is a pointer so we can use a different attribute type on create - CSLock = new CriticalSection(MUTEX_ATTRIBUTE_RECURSIVE); -} - -Mutex::~Mutex() { - safe_delete(CSLock); -#ifdef DEBUG - stack.clear(); -#endif -} - -void Mutex::SetName(string in_name) { -#ifdef DEBUG - name = in_name; -#endif -} - -void Mutex::lock() { -#ifdef DEBUG - int i = 0; -#endif - if (name.length() > 0) { - while (mlocked) { -#ifdef DEBUG - if (i > MUTEX_TIMEOUT_MILLISECONDS) { - LogWrite(MUTEX__ERROR, 0, "Mutex", "Possible deadlock attempt by '%s'!", name.c_str()); - return; - } - i++; -#endif - Sleep(1); - } - } - mlocked = true; - CSLock->lock(); -} - -bool Mutex::trylock() { - return CSLock->trylock(); -} - -void Mutex::unlock() { - CSLock->unlock(); - mlocked = false; -} - -void Mutex::readlock(const char* function, int32 line) { -#ifdef DEBUG - int32 i = 0; -#endif - while (true) { - //Loop until there isn't a writer, then we can read! - CSRead.lock(); - if (!writing) { - readers++; - CSRead.unlock(); -#ifdef DEBUG - CSStack.lock(); - if (function) - stack[(string)function]++; - CSStack.unlock(); -#endif - return; - } - CSRead.unlock(); -#ifdef DEBUG - if (i > MUTEX_TIMEOUT_MILLISECONDS) { - LogWrite(MUTEX__ERROR, 0, "Mutex", "The mutex %s called from %s at line %u timed out waiting for a readlock!", name.c_str(), function ? function : "name_not_provided", line); - LogWrite(MUTEX__ERROR, 0, "Mutex", "The following functions had locks:"); - map::iterator itr; - CSStack.lock(); - for (itr = stack.begin(); itr != stack.end(); itr++) { - if (itr->second > 0 && itr->first.length() > 0) - LogWrite(MUTEX__ERROR, 0, "Mutex", "%s, number of locks = %u", itr->first.c_str(), itr->second); - } - CSStack.unlock(); - i = 0; - continue; - } - i++; -#endif - Sleep(1); - } -} - -void Mutex::releasereadlock(const char* function, int32 line) { - //Wait for the readcount lock - CSRead.lock(); - //Lower the readcount by one, when readcount is 0 writers may start writing - readers--; - CSRead.unlock(); -#ifdef DEBUG - CSStack.lock(); - if (function) { - map::iterator itr = stack.find((string)function); - if (itr != stack.end()) { - if (--(itr->second) == 0) { - stack.erase(itr); - } - } - } - CSStack.unlock(); -#endif -} - -bool Mutex::tryreadlock(const char* function) { - //This returns true if able to instantly obtain a readlock, false if not - CSRead.lock(); - if (!writing) { - readers++; - CSRead.unlock(); - } - else { - CSRead.unlock(); - return false; - } - -#ifdef DEBUG - CSStack.lock(); - if (function) - stack[(string)function]++; - CSStack.unlock(); -#endif - - return true; -} - -void Mutex::writelock(const char* function, int32 line) { - //Wait until the writer lock becomes available, then we can be the only writer! -#ifdef DEBUG - int32 i = 0; -#endif - while (!CSWrite.trylock()) { -#ifdef DEBUG - if (i > MUTEX_TIMEOUT_MILLISECONDS) { - LogWrite(MUTEX__ERROR, 0, "Mutex", "The mutex %s called from %s at line %u timed out waiting on another writelock!", name.c_str(), function ? function : "name_not_provided", line); - LogWrite(MUTEX__ERROR, 0, "Mutex", "The following functions had locks:"); - map::iterator itr; - CSStack.lock(); - for (itr = stack.begin(); itr != stack.end(); itr++) { - if (itr->second > 0 && itr->first.length() > 0) - LogWrite(MUTEX__ERROR, 0, "Mutex", "%s, number of locks = %u", itr->first.c_str(), itr->second); - } - CSStack.unlock(); - i = 0; - continue; - } - i++; -#endif - Sleep(1); - } - waitReaders(function, line); -#ifdef DEBUG - CSStack.lock(); - if (function) - stack[(string)function]++; - CSStack.unlock(); -#endif -} - -void Mutex::releasewritelock(const char* function, int32 line) { - //Wait for the readcount lock - CSRead.lock(); - //Readers are aloud again - writing = false; - CSRead.unlock(); - //Allow other writers to write - CSWrite.unlock(); -#ifdef DEBUG - CSStack.lock(); - if (function) { - map::iterator itr = stack.find((string)function); - if (itr != stack.end()) { - if (--(itr->second) == 0) { - stack.erase(itr); - } - } - } - CSStack.unlock(); -#endif -} - -bool Mutex::trywritelock(const char* function) { - //This returns true if able to instantly obtain a writelock, false if not - if (CSWrite.trylock()) { - CSRead.lock(); - if (readers == 0) - writing = true; - CSRead.unlock(); - if (!writing) { - CSWrite.unlock(); - return false; - } - } - else - return false; - -#ifdef DEBUG - CSStack.lock(); - if (function) - stack[(string)function]++; - CSStack.unlock(); -#endif - - return true; -} - -void Mutex::waitReaders(const char* function, int32 line) -{ - //Wait for all current readers to stop, then we can write! -#ifdef DEBUG - int32 i = 0; -#endif - while (true) - { - CSRead.lock(); - if (readers == 0) - { - writing = true; - CSRead.unlock(); - break; - } - CSRead.unlock(); -#ifdef DEBUG - if (i > MUTEX_TIMEOUT_MILLISECONDS) { - LogWrite(MUTEX__ERROR, 0, "Mutex", "The mutex %s called from %s at line %u timed out while waiting on readers!", name.c_str(), function ? function : "name_not_provided", line); - LogWrite(MUTEX__ERROR, 0, "Mutex", "The following functions had locks:"); - map::iterator itr; - CSStack.lock(); - for (itr = stack.begin(); itr != stack.end(); itr++) { - if (itr->second > 0 && itr->first.length() > 0) - LogWrite(MUTEX__ERROR, 0, "Mutex", "%s, number of locks = %u", itr->first.c_str(), itr->second); - } - CSStack.unlock(); - i = 0; - continue; - } - i++; -#endif - Sleep(1); - } -} - -LockMutex::LockMutex(Mutex* in_mut, bool iLock) { - mut = in_mut; - locked = iLock; - if (locked) { - mut->lock(); - } -} - -LockMutex::~LockMutex() { - if (locked) { - mut->unlock(); - } -} - -void LockMutex::unlock() { - if (locked) - mut->unlock(); - locked = false; -} - -void LockMutex::lock() { - if (!locked) - mut->lock(); - locked = true; -} - -CriticalSection::CriticalSection(int attribute) { -#ifdef WIN32 - InitializeCriticalSection(&CSMutex); -#else - pthread_mutexattr_init(&type_attribute); - switch (attribute) - { - case MUTEX_ATTRIBUTE_FAST: - pthread_mutexattr_settype(&type_attribute, PTHREAD_MUTEX_FAST_NP); - break; - case MUTEX_ATTRIBUTE_RECURSIVE: - pthread_mutexattr_settype(&type_attribute, PTHREAD_MUTEX_RECURSIVE_NP); - break; - case MUTEX_ATTRIBUTE_ERRORCHK: - pthread_mutexattr_settype(&type_attribute, PTHREAD_MUTEX_ERRORCHECK_NP); - break; - default: - LogWrite(MUTEX__DEBUG, 0, "Critical Section", "Invalid mutex attribute type! Using PTHREAD_MUTEX_FAST_NP"); - pthread_mutexattr_settype(&type_attribute, PTHREAD_MUTEX_FAST_NP); - break; - } - pthread_mutex_init(&CSMutex, &type_attribute); -#endif -} - -CriticalSection::~CriticalSection() { -#ifdef WIN32 - DeleteCriticalSection(&CSMutex); -#else - pthread_mutex_destroy(&CSMutex); - pthread_mutexattr_destroy(&type_attribute); -#endif -} - -void CriticalSection::lock() { - //Waits for a lock on this critical section -#ifdef WIN32 - EnterCriticalSection(&CSMutex); -#else - pthread_mutex_lock(&CSMutex); -#endif -} - -void CriticalSection::unlock() { - //Gets rid of one of the current thread's locks on this critical section -#ifdef WIN32 - LeaveCriticalSection(&CSMutex); -#else - pthread_mutex_unlock(&CSMutex); -#endif -} - -bool CriticalSection::trylock() { - //Returns true if able to instantly get a lock on this critical section, false if not -#ifdef WIN32 - return TryEnterCriticalSection(&CSMutex); -#else - return (pthread_mutex_trylock(&CSMutex) == 0); -#endif -} - diff --git a/source/common/Mutex.h b/source/common/Mutex.h deleted file mode 100644 index ae96333..0000000 --- a/source/common/Mutex.h +++ /dev/null @@ -1,103 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef MYMUTEX_H -#define MYMUTEX_H -#ifdef WIN32 - #include - #include -#else - #include - #include "../common/unix.h" -#endif -#include "../common/types.h" -#include -#include - -#define MUTEX_ATTRIBUTE_FAST 1 -#define MUTEX_ATTRIBUTE_RECURSIVE 2 -#define MUTEX_ATTRIBUTE_ERRORCHK 3 -#define MUTEX_TIMEOUT_MILLISECONDS 10000 - -class CriticalSection { -public: - CriticalSection(int attribute = MUTEX_ATTRIBUTE_FAST); - ~CriticalSection(); - void lock(); - void unlock(); - bool trylock(); -private: -#ifdef WIN32 - CRITICAL_SECTION CSMutex; -#else - pthread_mutex_t CSMutex; - pthread_mutexattr_t type_attribute; -#endif -}; - -class Mutex { -public: - Mutex(); - ~Mutex(); - - void lock(); - void unlock(); - bool trylock(); - - void readlock(const char* function = 0, int32 line = 0); - void releasereadlock(const char* function = 0, int32 line = 0); - bool tryreadlock(const char* function = 0); - - void writelock(const char* function = 0, int32 line = 0); - void releasewritelock(const char* function = 0, int32 line = 0); - bool trywritelock(const char* function = 0); - - void waitReaders(const char* function = 0, int32 line = 0); - - void SetName(string in_name); -private: - CriticalSection CSRead; - CriticalSection CSWrite; - CriticalSection* CSLock; - -#ifdef DEBUG //Used for debugging only - CriticalSection CSStack; - map stack; -#endif - - int readers; - bool writing; - volatile bool mlocked; - string name; -}; - - -class LockMutex { -public: - LockMutex(Mutex* in_mut, bool iLock = true); - ~LockMutex(); - void unlock(); - void lock(); -private: - bool locked; - Mutex* mut; -}; - - -#endif diff --git a/source/common/RC4.cpp b/source/common/RC4.cpp deleted file mode 100644 index 15d9f78..0000000 --- a/source/common/RC4.cpp +++ /dev/null @@ -1,93 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "RC4.h" -#include - -static bool g_bInitStateInitialized = false; -static uchar g_byInitState[256]; - -RC4::RC4(int64 nKey) -{ - if( !g_bInitStateInitialized ) - { - for(int16 i = 0; i < 256; i++ ) - g_byInitState[i] = i; - } - Init(nKey); -} - -RC4::~RC4() -{ -} - -void RC4::Init(int64 nKey) -{ - memcpy(m_state, g_byInitState, 256); - m_x = 0; - m_y = 0; - - ulong dwKeyIndex = 0; - ulong dwStateIndex = 0; - uchar* pKey = (uchar*)&nKey; - for(int16 i = 0; i < 256; i++ ) - { - ulong dwTemp = m_state[i]; - dwStateIndex += pKey[dwKeyIndex] + dwTemp; - dwStateIndex &= 0xFF; - m_state[i] = m_state[dwStateIndex]; - m_state[dwStateIndex] = (uchar)dwTemp; - dwKeyIndex++; - dwKeyIndex &= 7; - } -} - -// A = m_state[X + 1] -// B = m_state[Y + A] -// C ^= m_state[(A + B)] - -// X = 20 -// Y = ? -// C = 0 -// m_state[(A + B)] = Cypher Byte - -void RC4::Cypher(uchar* pBuffer, int32 nLength) -{ - int32 nOffset = 0; - uchar byKey1 = m_x; - uchar byKey2 = m_y; - if( nLength > 0 ) - { - do - { - byKey1++; - uchar byKeyVal1 = m_state[byKey1]; - - byKey2 += byKeyVal1; - uchar byKeyVal2 = m_state[byKey2]; - - m_state[byKey1] = byKeyVal2; - m_state[byKey2] = byKeyVal1; - - pBuffer[nOffset++] ^= m_state[(byKeyVal1 + byKeyVal2) & 0xFF]; - } while( nOffset < nLength ); - } - m_x = byKey1; - m_y = byKey2; -} diff --git a/source/common/RC4.h b/source/common/RC4.h deleted file mode 100644 index 52a3ea9..0000000 --- a/source/common/RC4.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef _EQ2_RC4_H -#define _EQ2_RC4_H -#include "../common/types.h" -class RC4 -{ -public: - RC4(int64 nKey); - ~RC4(); - - void Init(int64 nKey); - void Cypher(uchar* pData, int32 nLen); - -private: - uchar m_state[256]; - uchar m_x; - uchar m_y; -}; -#endif - diff --git a/source/common/TCPConnection.cpp b/source/common/TCPConnection.cpp deleted file mode 100644 index 81493b2..0000000 --- a/source/common/TCPConnection.cpp +++ /dev/null @@ -1,1729 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "../common/debug.h" - -#include -using namespace std; -#include -#include -#include -using namespace std; - -#include "TCPConnection.h" -#include "../common/servertalk.h" -#include "../common/timer.h" -#include "../common/packet_dump.h" -#include "Log.h" - -#ifdef FREEBSD //Timothy Whitman - January 7, 2003 -#define MSG_NOSIGNAL 0 -#endif - -#ifdef WIN32 -InitWinsock winsock; -#endif - -#define LOOP_GRANULARITY 3 //# of ms between checking our socket/queues -#define SERVER_LOOP_GRANULARITY 3 //# of ms between checking our socket/queues - -#define TCPN_DEBUG 0 -#define TCPN_DEBUG_Console 0 -#define TCPN_DEBUG_Memory 0 -#define TCPN_LOG_PACKETS 0 -#define TCPN_LOG_RAW_DATA_OUT 0 -#define TCPN_LOG_RAW_DATA_IN 0 - -TCPConnection::TCPNetPacket_Struct* TCPConnection::MakePacket(ServerPacket* pack, int32 iDestination) { - sint32 size = sizeof(TCPNetPacket_Struct) + pack->size; - if (pack->compressed) { - size += 4; - } - if (iDestination) { - size += 4; - } - TCPNetPacket_Struct* tnps = (TCPNetPacket_Struct*) new uchar[size]; - tnps->size = size; - tnps->opcode = pack->opcode; - *((int8*) &tnps->flags) = 0; - uchar* buffer = tnps->buffer; - if (pack->compressed) { - tnps->flags.compressed = 1; - *((sint32*) buffer) = pack->InflatedSize; - buffer += 4; - } - if (iDestination) { - tnps->flags.destination = 1; - *((sint32*) buffer) = iDestination; - buffer += 4; - } - memcpy(buffer, pack->pBuffer, pack->size); - return tnps; -} - -TCPConnection::TCPConnection(bool iOldFormat, TCPServer* iRelayServer, eTCPMode iMode) { - id = 0; - Server = iRelayServer; - if (Server) - RelayServer = true; - else - RelayServer = false; - RelayLink = 0; - RelayCount = 0; - RemoteID = 0; - pOldFormat = iOldFormat; - ConnectionType = Outgoing; - TCPMode = iMode; - pState = TCPS_Ready; - pFree = false; - pEcho = false; - sock = 0; - rIP = 0; - rPort = 0; - keepalive_timer = new Timer(SERVER_TIMEOUT); - timeout_timer = new Timer(SERVER_TIMEOUT * 2); - recvbuf = 0; - sendbuf = 0; - pRunLoop = false; - charAsyncConnect = 0; - pAsyncConnect = false; - connection_socket = 0; - recvbuf_size = 0; - recvbuf_used = 0; - recvbuf_echo = 0; - sendbuf_size = 0; - sendbuf_used = 0; -#if TCPN_DEBUG_Memory >= 7 - cout << "Constructor #1 on outgoing TCP# " << GetID() << endl; -#endif -} - -TCPConnection::TCPConnection(TCPServer* iServer, SOCKET in_socket, int32 irIP, int16 irPort, bool iOldFormat) { - Server = iServer; - RelayLink = 0; - RelayServer = false; - RelayCount = 0; - RemoteID = 0; - id = Server->GetNextID(); - ConnectionType = Incomming; - pOldFormat = iOldFormat; - TCPMode = modePacket; - pState = TCPS_Connected; - pFree = false; - pEcho = false; - sock = 0; - connection_socket = in_socket; - rIP = irIP; - rPort = irPort; - keepalive_timer = new Timer(SERVER_TIMEOUT); - timeout_timer = new Timer(SERVER_TIMEOUT * 2); - recvbuf = 0; - sendbuf = 0; - pRunLoop = false; - charAsyncConnect = 0; - pAsyncConnect = false; - recvbuf_size = 0; - recvbuf_used = 0; - recvbuf_echo = 0; - sendbuf_size = 0; - sendbuf_used = 0; -#if TCPN_DEBUG_Memory >= 7 - cout << "Constructor #2 on outgoing TCP# " << GetID() << endl; -#endif -} - -TCPConnection::TCPConnection(TCPServer* iServer, TCPConnection* iRelayLink, int32 iRemoteID, int32 irIP, int16 irPort) { - Server = iServer; - RelayLink = iRelayLink; - RelayServer = true; - id = Server->GetNextID(); - RelayCount = 0; - RemoteID = iRemoteID; - if (!RemoteID) - ThrowError("Error: TCPConnection: RemoteID == 0 on RelayLink constructor"); - pOldFormat = false; - ConnectionType = Incomming; - TCPMode = modePacket; - pState = TCPS_Connected; - pFree = false; - pEcho = false; - sock = 0; - connection_socket = 0; - rIP = irIP; - rPort = irPort; - keepalive_timer = 0; - timeout_timer = 0; - recvbuf = 0; - sendbuf = 0; - pRunLoop = false; - charAsyncConnect = 0; - pAsyncConnect = false; - recvbuf_size = 0; - recvbuf_used = 0; - recvbuf_echo = 0; - sendbuf_size = 0; - sendbuf_used = 0; -#if TCPN_DEBUG_Memory >= 7 - cout << "Constructor #3 on outgoing TCP# " << GetID() << endl; -#endif -} - -TCPConnection::~TCPConnection() { - Disconnect(); - ClearBuffers(); - if (ConnectionType == Outgoing) { - MRunLoop.lock(); - pRunLoop = false; - MRunLoop.unlock(); - MLoopRunning.lock(); - MLoopRunning.unlock(); -#if TCPN_DEBUG_Memory >= 6 - cout << "Deconstructor on outgoing TCP# " << GetID() << endl; -#endif - } -#if TCPN_DEBUG_Memory >= 5 - else { - cout << "Deconstructor on incomming TCP# " << GetID() << endl; - } -#endif - safe_delete(keepalive_timer); - safe_delete(timeout_timer); - safe_delete_array(recvbuf); - safe_delete_array(sendbuf); - safe_delete_array(charAsyncConnect); -} - -void TCPConnection::SetState(int8 in_state) { - MState.lock(); - pState = in_state; - MState.unlock(); -} - -int8 TCPConnection::GetState() { - int8 ret; - MState.lock(); - ret = pState; - MState.unlock(); - return ret; -} - -void TCPConnection::Free() { - if (ConnectionType == Outgoing) { - ThrowError("TCPConnection::Free() called on an Outgoing connection"); - } -#if TCPN_DEBUG_Memory >= 5 - cout << "Free on TCP# " << GetID() << endl; -#endif - Disconnect(); - pFree = true; -} - -bool TCPConnection::SendPacket(ServerPacket* pack, int32 iDestination) { - LockMutex lock(&MState); - if (!Connected()) - return false; - eTCPMode tmp = GetMode(); - if (tmp != modePacket && tmp != modeTransition) - return false; - if (RemoteID) - return RelayLink->SendPacket(pack, RemoteID); - else { - TCPNetPacket_Struct* tnps = MakePacket(pack, iDestination); - if (tmp == modeTransition) { - InModeQueuePush(tnps); - } - else { -#if TCPN_LOG_PACKETS >= 1 - if (pack && pack->opcode != 0) { - struct in_addr in; - in.s_addr = GetrIP(); - CoutTimestamp(true); - cout << ": Logging outgoing TCP packet. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << endl; -#if TCPN_LOG_PACKETS == 2 - if (pack->size >= 32) - DumpPacket(pack->pBuffer, 32); - else - DumpPacket(pack); -#endif -#if TCPN_LOG_PACKETS >= 3 - DumpPacket(pack); -#endif - } -#endif - ServerSendQueuePushEnd((uchar**) &tnps, tnps->size); - } - } - return true; -} - -bool TCPConnection::SendPacket(TCPNetPacket_Struct* tnps) { - LockMutex lock(&MState); - if (RemoteID) - return false; - if (!Connected()) - return false; - eTCPMode tmp = GetMode(); - if (tmp == modeTransition) { - TCPNetPacket_Struct* tnps2 = (TCPNetPacket_Struct*) new uchar[tnps->size]; - memcpy(tnps2, tnps, tnps->size); - InModeQueuePush(tnps2); - return true; - } - if (GetMode() != modePacket) - return false; -#if TCPN_LOG_PACKETS >= 1 - if (tnps && tnps->opcode != 0) { - struct in_addr in; - in.s_addr = GetrIP(); - CoutTimestamp(true); - cout << ": Logging outgoing TCP NetPacket. OPCode: 0x" << hex << setw(4) << setfill('0') << tnps->opcode << dec << ", size: " << setw(5) << setfill(' ') << tnps->size << " " << inet_ntoa(in) << ":" << GetrPort(); - if (pOldFormat) - cout << " (OldFormat)"; - cout << endl; -#if TCPN_LOG_PACKETS == 2 - if (tnps->size >= 32) - DumpPacket((uchar*) tnps, 32); - else - DumpPacket((uchar*) tnps, tnps->size); -#endif -#if TCPN_LOG_PACKETS >= 3 - DumpPacket((uchar*) tnps, tnps->size); -#endif - } -#endif - ServerSendQueuePushEnd((const uchar*) tnps, tnps->size); - return true; -} - -bool TCPConnection::Send(const uchar* data, sint32 size) { - if (!Connected()) - return false; - if (GetMode() != modeConsole) - return false; - if (!size) - return true; - ServerSendQueuePushEnd(data, size); - return true; -} - -void TCPConnection::InModeQueuePush(TCPNetPacket_Struct* tnps) { - MSendQueue.lock(); - InModeQueue.push(tnps); - MSendQueue.unlock(); -} - -void TCPConnection::ServerSendQueuePushEnd(const uchar* data, sint32 size) { - MSendQueue.lock(); - if (sendbuf == 0) { - sendbuf = new uchar[size]; - sendbuf_size = size; - sendbuf_used = 0; - } - else if (size > (sendbuf_size - sendbuf_used)) { - sendbuf_size += size + 1024; - uchar* tmp = new uchar[sendbuf_size]; - memcpy(tmp, sendbuf, sendbuf_used); - safe_delete_array(sendbuf); - sendbuf = tmp; - } - memcpy(&sendbuf[sendbuf_used], data, size); - sendbuf_used += size; - MSendQueue.unlock(); -} - -void TCPConnection::ServerSendQueuePushEnd(uchar** data, sint32 size) { - MSendQueue.lock(); - if (sendbuf == 0) { - sendbuf = *data; - sendbuf_size = size; - sendbuf_used = size; - MSendQueue.unlock(); - *data = 0; - return; - } - if (size > (sendbuf_size - sendbuf_used)) { - sendbuf_size += size; - uchar* tmp = new uchar[sendbuf_size]; - memcpy(tmp, sendbuf, sendbuf_used); - safe_delete_array(sendbuf); - sendbuf = tmp; - } - memcpy(&sendbuf[sendbuf_used], *data, size); - sendbuf_used += size; - MSendQueue.unlock(); - delete[] (TCPNetPacket_Struct*)*data; -} - -void TCPConnection::ServerSendQueuePushFront(uchar* data, sint32 size) { - MSendQueue.lock(); - if (sendbuf == 0) { - sendbuf = new uchar[size]; - sendbuf_size = size; - sendbuf_used = 0; - } - else if (size > (sendbuf_size - sendbuf_used)) { - sendbuf_size += size; - uchar* tmp = new uchar[sendbuf_size]; - memcpy(&tmp[size], sendbuf, sendbuf_used); - safe_delete_array(sendbuf); - sendbuf = tmp; - } - memcpy(sendbuf, data, size); - sendbuf_used += size; - MSendQueue.unlock(); -} - -bool TCPConnection::ServerSendQueuePop(uchar** data, sint32* size) { - bool ret; - if (!MSendQueue.trylock()) - return false; - if (sendbuf) { - *data = sendbuf; - *size = sendbuf_used; - sendbuf = 0; - ret = true; - } - else { - ret = false; - } - MSendQueue.unlock(); - return ret; -} - -ServerPacket* TCPConnection::PopPacket() { - ServerPacket* ret; - if (!MOutQueueLock.trylock()) - return 0; - ret = OutQueue.pop(); - MOutQueueLock.unlock(); - return ret; -} - -char* TCPConnection::PopLine() { - char* ret; - if (!MOutQueueLock.trylock()) - return 0; - ret = (char*) LineOutQueue.pop(); - MOutQueueLock.unlock(); - return ret; -} - -void TCPConnection::OutQueuePush(ServerPacket* pack) { - MOutQueueLock.lock(); - OutQueue.push(pack); - MOutQueueLock.unlock(); -} - -void TCPConnection::LineOutQueuePush(char* line) { -#if defined(GOTFRAGS) && 0 - if (strcmp(line, "**CRASHME**") == 0) { - int i = 0; - cout << (5 / i) << endl; - } -#endif - if (strcmp(line, "**PACKETMODE**") == 0) { - MSendQueue.lock(); - safe_delete_array(sendbuf); - if (TCPMode == modeConsole) - Send((const uchar*) "\0**PACKETMODE**\r", 16); - TCPMode = modePacket; - TCPNetPacket_Struct* tnps = 0; - while ((tnps = InModeQueue.pop())) { - SendPacket(tnps); - safe_delete_array(tnps); - } - MSendQueue.unlock(); - safe_delete_array(line); - return; - } - MOutQueueLock.lock(); - LineOutQueue.push(line); - MOutQueueLock.unlock(); -} - -void TCPConnection::Disconnect(bool iSendRelayDisconnect) { - if (connection_socket != INVALID_SOCKET && connection_socket != 0) { - MState.lock(); - if (pState == TCPS_Connected || pState == TCPS_Disconnecting || pState == TCPS_Disconnected) - SendData(); - pState = TCPS_Closing; - MState.unlock(); - shutdown(connection_socket, 0x01); - shutdown(connection_socket, 0x00); -#ifdef WIN32 - closesocket(connection_socket); -#else - close(connection_socket); -#endif - connection_socket = 0; - rIP = 0; - rPort = 0; - ClearBuffers(); - } - SetState(TCPS_Ready); - if (RelayLink) { - RelayLink->RemoveRelay(this, iSendRelayDisconnect); - RelayLink = 0; - } -} - -bool TCPConnection::GetAsyncConnect() { - bool ret; - MAsyncConnect.lock(); - ret = pAsyncConnect; - MAsyncConnect.unlock(); - return ret; -} - -bool TCPConnection::SetAsyncConnect(bool iValue) { - bool ret; - MAsyncConnect.lock(); - ret = pAsyncConnect; - pAsyncConnect = iValue; - MAsyncConnect.unlock(); - return ret; -} - -void TCPConnection::AsyncConnect(char* irAddress, int16 irPort) { - if (ConnectionType != Outgoing) { - // If this code runs, we got serious problems - // Crash and burn. - ThrowError("TCPConnection::AsyncConnect() call on a Incomming connection object!"); - return; - } - if (GetState() != TCPS_Ready) - return; - MAsyncConnect.lock(); - if (pAsyncConnect) { - MAsyncConnect.unlock(); - return; - } - pAsyncConnect = true; - safe_delete_array(charAsyncConnect); - charAsyncConnect = new char[strlen(irAddress) + 1]; - strcpy(charAsyncConnect, irAddress); - rPort = irPort; - MAsyncConnect.unlock(); - if (!pRunLoop) { - pRunLoop = true; -#ifdef WIN32 - _beginthread(TCPConnectionLoop, 0, this); -#else - pthread_t thread; - pthread_create(&thread, NULL, TCPConnectionLoop, this); - pthread_detach(thread); -#endif - } - return; -} - -void TCPConnection::AsyncConnect(int32 irIP, int16 irPort) { - if (ConnectionType != Outgoing) { - // If this code runs, we got serious problems - // Crash and burn. - ThrowError("TCPConnection::AsyncConnect() call on a Incomming connection object!"); - return; - } - if (GetState() != TCPS_Ready) - return; - MAsyncConnect.lock(); - if (pAsyncConnect) { - MAsyncConnect.unlock(); - return; - } - pAsyncConnect = true; - safe_delete(charAsyncConnect); - rIP = irIP; - rPort = irPort; - MAsyncConnect.unlock(); - if (!pRunLoop) { - pRunLoop = true; -#ifdef WIN32 - _beginthread(TCPConnectionLoop, 0, this); -#else - pthread_t thread; - pthread_create(&thread, NULL, TCPConnectionLoop, this); - pthread_detach(thread); -#endif - } - return; -} - -bool TCPConnection::Connect(char* irAddress, int16 irPort, char* errbuf) { - if (errbuf) - errbuf[0] = 0; - int32 tmpIP = ResolveIP(irAddress); - if (!tmpIP) { - if (errbuf) { -#ifdef WIN32 - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): Couldnt resolve hostname. Error: %i", WSAGetLastError()); -#else - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): Couldnt resolve hostname. Error #%i: %s", errno, strerror(errno)); -#endif - } - return false; - } - return Connect(tmpIP, irPort, errbuf); -} - -bool TCPConnection::Connect(int32 in_ip, int16 in_port, char* errbuf) { - if (errbuf) - errbuf[0] = 0; - if (ConnectionType != Outgoing) { - // If this code runs, we got serious problems - // Crash and burn. - ThrowError("TCPConnection::Connect() call on a Incomming connection object!"); - return false; - } - MState.lock(); - if (pState == TCPS_Ready) { - pState = TCPS_Connecting; - } - else { - MState.unlock(); - SetAsyncConnect(false); - return false; - } - MState.unlock(); - if (!pRunLoop) { - pRunLoop = true; -#ifdef WIN32 - _beginthread(TCPConnectionLoop, 0, this); -#else - pthread_t thread; - pthread_create(&thread, NULL, TCPConnectionLoop, this); - pthread_detach(thread); -#endif - } - - connection_socket = INVALID_SOCKET; - struct sockaddr_in server_sin; - // struct in_addr in; - - if ((connection_socket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET || connection_socket == 0) { -#ifdef WIN32 - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): Allocating socket failed. Error: %i", WSAGetLastError()); -#else - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): Allocating socket failed. Error: %s", strerror(errno)); -#endif - SetState(TCPS_Ready); - SetAsyncConnect(false); - return false; - } - server_sin.sin_family = AF_INET; - server_sin.sin_addr.s_addr = in_ip; - server_sin.sin_port = htons(in_port); - - // Establish a connection to the server socket. -#ifdef WIN32 - if (connect(connection_socket, (PSOCKADDR) &server_sin, sizeof (server_sin)) == SOCKET_ERROR) { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): connect() failed. Error: %i", WSAGetLastError()); - closesocket(connection_socket); - connection_socket = 0; - SetState(TCPS_Ready); - SetAsyncConnect(false); - return false; - } -#else - if (connect(connection_socket, (struct sockaddr *) &server_sin, sizeof (server_sin)) == SOCKET_ERROR) { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): connect() failed. Error: %s", strerror(errno)); - close(connection_socket); - connection_socket = 0; - SetState(TCPS_Ready); - SetAsyncConnect(false); - return false; - } -#endif - int bufsize = 64 * 1024; // 64kbyte recieve buffer, up from default of 8k - setsockopt(connection_socket, SOL_SOCKET, SO_RCVBUF, (char*) &bufsize, sizeof(bufsize)); -#ifdef WIN32 - unsigned long nonblocking = 1; - ioctlsocket(connection_socket, FIONBIO, &nonblocking); -#else - fcntl(connection_socket, F_SETFL, O_NONBLOCK); -#endif - - SetEcho(false); - MSendQueue.lock(); - ClearBuffers(); - TCPMode = modePacket; - - MSendQueue.unlock(); - - rIP = in_ip; - rPort = in_port; - SetState(TCPS_Connected); - SetAsyncConnect(false); - return true; -} - -void TCPConnection::ClearBuffers() { - LockMutex lock1(&MSendQueue); - LockMutex lock2(&MOutQueueLock); - LockMutex lock3(&MRunLoop); - LockMutex lock4(&MState); - safe_delete_array(recvbuf); - safe_delete_array(sendbuf); - ServerPacket* pack = 0; - while ((pack = PopPacket())) - safe_delete(pack); - TCPNetPacket_Struct* tnps = 0; - while ((tnps = InModeQueue.pop())) - safe_delete(tnps); - char* line = 0; - while ((line = LineOutQueue.pop())) - safe_delete_array(line); - keepalive_timer->Start(); - timeout_timer->Start(); -} - -bool TCPConnection::CheckNetActive() { - MState.lock(); - if (pState == TCPS_Connected || pState == TCPS_Disconnecting) { - MState.unlock(); - return true; - } - MState.unlock(); - return false; -} - -bool TCPConnection::Process() { - char errbuf[TCPConnection_ErrorBufferSize]; - if (!CheckNetActive()) { - if (ConnectionType == Outgoing) { - if (GetAsyncConnect()) { - if (charAsyncConnect) - rIP = ResolveIP(charAsyncConnect); - Connect(rIP, rPort); - } - } - if (GetState() == TCPS_Disconnected) { - Disconnect(); - return false; - } - else if (GetState() == TCPS_Connecting) - return true; - else - return false; - } - if (!SendData(errbuf)) { - struct in_addr in; - in.s_addr = GetrIP(); - cout << inet_ntoa(in) << ":" << GetrPort() << ": " << errbuf << endl; - return false; - } - if (!Connected()) - return false; - if (!RecvData(errbuf)) { - struct in_addr in; - in.s_addr = GetrIP(); - cout << inet_ntoa(in) << ":" << GetrPort() << ": " << errbuf << endl; - return false; - } - return true; -} - -bool TCPConnection::RecvData(char* errbuf) { - if (errbuf) - errbuf[0] = 0; - if (!Connected()) { - return false; - } - - int status = 0; - if (recvbuf == 0) { - recvbuf = new uchar[5120]; - recvbuf_size = 5120; - recvbuf_used = 0; - recvbuf_echo = 0; - } - else if ((recvbuf_size - recvbuf_used) < 2048) { - uchar* tmpbuf = new uchar[recvbuf_size + 5120]; - memcpy(tmpbuf, recvbuf, recvbuf_used); - recvbuf_size += 5120; - safe_delete_array(recvbuf); - recvbuf = tmpbuf; - if (recvbuf_size >= MaxTCPReceiveBufferSize) { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::RecvData(): recvbuf_size >= MaxTCPReceiveBufferSize"); - return false; - } - } - - status = recv(connection_socket, (char *) &recvbuf[recvbuf_used], (recvbuf_size - recvbuf_used), 0); - if (status >= 1) { -#if TCPN_LOG_RAW_DATA_IN >= 1 - struct in_addr in; - in.s_addr = GetrIP(); - CoutTimestamp(true); - cout << ": Read " << status << " bytes from network. (recvbuf_used = " << recvbuf_used << ") " << inet_ntoa(in) << ":" << GetrPort(); - if (pOldFormat) - cout << " (OldFormat)"; - cout << endl; -#if TCPN_LOG_RAW_DATA_IN == 2 - sint32 tmp = status; - if (tmp > 32) - tmp = 32; - DumpPacket(&recvbuf[recvbuf_used], status); -#elif TCPN_LOG_RAW_DATA_IN >= 3 - DumpPacket(&recvbuf[recvbuf_used], status); -#endif -#endif - recvbuf_used += status; - timeout_timer->Start(); - if (!ProcessReceivedData(errbuf)) - return false; - } - else if (status == SOCKET_ERROR) { -#ifdef WIN32 - if (!(WSAGetLastError() == WSAEWOULDBLOCK)) { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::RecvData(): Error: %i", WSAGetLastError()); - return false; - } -#else - if (!(errno == EWOULDBLOCK)) { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::RecvData(): Error: %s", strerror(errno)); - return false; - } -#endif - } - if ((TCPMode == modePacket || TCPMode == modeTransition) && timeout_timer->Check()) { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::RecvData(): Connection timeout"); - return false; - } - - return true; -} - - -bool TCPConnection::GetEcho() { - bool ret; - MEcho.lock(); - ret = pEcho; - MEcho.unlock(); - return ret; -} - -void TCPConnection::SetEcho(bool iValue) { - MEcho.lock(); - pEcho = iValue; - MEcho.unlock(); -} - -bool TCPConnection::ProcessReceivedData(char* errbuf) { - if (errbuf) - errbuf[0] = 0; - if (!recvbuf) - return true; - if (TCPMode == modePacket) { - //if (pOldFormat) - // return ProcessReceivedDataAsOldPackets(errbuf); - //else - return ProcessReceivedDataAsPackets(errbuf); - } - else { -#if TCPN_DEBUG_Console >= 4 - if (recvbuf_used) { - cout << "Starting Processing: recvbuf=" << recvbuf_used << endl; - DumpPacket(recvbuf, recvbuf_used); - } -#endif - for (int i=0; i < recvbuf_used; i++) { - if (GetEcho() && i >= recvbuf_echo) { - Send(&recvbuf[i], 1); - recvbuf_echo = i + 1; - } - switch(recvbuf[i]) { - case 0: { // 0 is the code for clear buffer - if (i==0) { - recvbuf_used--; - recvbuf_echo--; - memcpy(recvbuf, &recvbuf[1], recvbuf_used); - i = -1; - } else { - if (i == recvbuf_used) { - safe_delete_array(recvbuf); - i = -1; - } - else { - uchar* tmpdel = recvbuf; - recvbuf = new uchar[recvbuf_size]; - memcpy(recvbuf, &tmpdel[i+1], recvbuf_used-i); - recvbuf_used -= i + 1; - recvbuf_echo -= i + 1; - safe_delete(tmpdel); - i = -1; - } - } -#if TCPN_DEBUG_Console >= 5 - cout << "Removed 0x00" << endl; - if (recvbuf_used) { - cout << "recvbuf left: " << recvbuf_used << endl; - DumpPacket(recvbuf, recvbuf_used); - } - else - cout << "recbuf left: None" << endl; -#endif - break; - } - case 10: - case 13: // newline marker - { - if (i==0) { // empty line - recvbuf_used--; - recvbuf_echo--; - memcpy(recvbuf, &recvbuf[1], recvbuf_used); - i = -1; - } else { - char* line = new char[i+1]; - memset(line, 0, i+1); - memcpy(line, recvbuf, i); -#if TCPN_DEBUG_Console >= 3 - cout << "Line Out: " << endl; - DumpPacket((uchar*) line, i); -#endif - //line[i] = 0; - uchar* tmpdel = recvbuf; - recvbuf = new uchar[recvbuf_size]; - recvbuf_used -= i+1; - recvbuf_echo -= i+1; - memcpy(recvbuf, &tmpdel[i+1], recvbuf_used); -#if TCPN_DEBUG_Console >= 5 - cout << "i+1=" << i+1 << endl; - if (recvbuf_used) { - cout << "recvbuf left: " << recvbuf_used << endl; - DumpPacket(recvbuf, recvbuf_used); - } - else - cout << "recbuf left: None" << endl; -#endif - safe_delete(tmpdel); - if (strlen(line) > 0) - LineOutQueuePush(line); - else - safe_delete_array(line); - if (TCPMode == modePacket) { - return ProcessReceivedDataAsPackets(errbuf); - } - i = -1; - } - break; - } - case 8: // backspace - { - if (i==0) { // nothin to backspace - recvbuf_used--; - recvbuf_echo--; - memcpy(recvbuf, &recvbuf[1], recvbuf_used); - i = -1; - } else { - uchar* tmpdel = recvbuf; - recvbuf = new uchar[recvbuf_size]; - memcpy(recvbuf, tmpdel, i-1); - memcpy(&recvbuf[i-1], &tmpdel[i+1], recvbuf_used-i); - recvbuf_used -= 2; - recvbuf_echo -= 2; - safe_delete(tmpdel); - i -= 2; - } - break; - } - } - } - if (recvbuf_used < 0) - safe_delete_array(recvbuf); - } - return true; -} - -bool TCPConnection::ProcessReceivedDataAsPackets(char* errbuf) { - if (errbuf) - errbuf[0] = 0; - sint32 base = 0; - sint32 size = 0; - uchar* buffer; - sint32 sizeReq = sizeof(TCPNetPacket_Struct); - ServerPacket* pack = 0; - while ((recvbuf_used - base) >= size) { - TCPNetPacket_Struct* tnps = (TCPNetPacket_Struct*) &recvbuf[base]; - buffer = tnps->buffer; - size = tnps->size; - - if (size < sizeReq || recvbuf_used < sizeReq || size >= MaxTCPReceiveBufferSize) { -#if TCPN_DEBUG_Memory >= 1 - cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBufferSize" << endl; -#endif - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::ProcessReceivedDataAsPackets(): size provided %i, recvbuf_used %i, checks failed: struct_size < %i || recvbuf_used < sizeReq || size >= MaxTCPReceiveBufferSize", size, recvbuf_used, sizeReq); - return false; - } - if ((recvbuf_used - base) >= size) { - // ok, we got enough data to make this packet! - safe_delete(pack); - pack = new ServerPacket; - pack->size = size - sizeof(TCPNetPacket_Struct); - // read headers - pack->opcode = tnps->opcode; - if (tnps->flags.compressed) { - sizeReq += 4; - if(size < sizeReq || recvbuf_used < sizeReq) - { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::ProcessReceivedDataAsPackets(Flags.Compressed): size provided %i, recvbuf_used %i, checks failed: struct_size < %i || recvbuf_used < sizeReq", size, recvbuf_used, sizeReq); - safe_delete(pack); - return false; - } - pack->compressed = true; - pack->InflatedSize = *((sint32*)buffer); - pack->size -= 4; - buffer += 4; - } - if (tnps->flags.destination) { - sizeReq += 4; - if(size < sizeReq || recvbuf_used < sizeReq) - { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::ProcessReceivedDataAsPackets(Flags.Destination): size provided %i, recvbuf_used %i, checks failed: struct_size < %i || recvbuf_used < sizeReq", size, recvbuf_used, sizeReq); - safe_delete(pack); - return false; - } - pack->destination = *((sint32*)buffer); - pack->size -= 4; - buffer += 4; - } - // end read headers - if (pack->size > 0) { - if (tnps->flags.compressed) { - // Lets decompress the packet here - pack->compressed = false; - if(pack->InflatedSize < MaxTCPReceiveBufferSize) - { - pack->pBuffer = new uchar[pack->InflatedSize]; - pack->size = InflatePacket(buffer, pack->size, pack->pBuffer, pack->InflatedSize); - if(!pack->size) - { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::ProcessReceivedDataAsPackets(InflatePacket): size provided %i, recvbuf_used: %i, sizeReq: %i, could not inflate packet", size, recvbuf_used, sizeReq); - - safe_delete(pack); - return false; - } - } - else - { - cout << "Invalid inflated packet." << endl; - safe_delete(pack); - return false; - } - } - else { - pack->pBuffer = new uchar[pack->size]; - memcpy(pack->pBuffer, buffer, pack->size); - } - } - if (pack->opcode == 0) { - if (pack->size) { -#if TCPN_DEBUG >= 2 - cout << "Received TCP Network layer packet" << endl; -#endif - ProcessNetworkLayerPacket(pack); - } -#if TCPN_DEBUG >= 5 - else { - cout << "Received TCP keepalive packet. (opcode=0)" << endl; - } -#endif - } - else { -#if TCPN_LOG_PACKETS >= 1 - if (pack && pack->opcode != 0) { - struct in_addr in; - in.s_addr = GetrIP(); - CoutTimestamp(true); - cout << ": Logging incoming TCP packet. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << endl; -#if TCPN_LOG_PACKETS == 2 - if (pack->size >= 32) - DumpPacket(pack->pBuffer, 32); - else - DumpPacket(pack); -#endif -#if TCPN_LOG_PACKETS >= 3 - DumpPacket(pack); -#endif - } -#endif - if (RelayServer && Server && pack->destination) { - TCPConnection* con = Server->GetConnection(pack->destination); - if (!con) { -#if TCPN_DEBUG >= 1 - cout << "Error relaying packet: con = 0" << endl; -#endif - } - else{ - con->OutQueuePush(pack); - pack = 0; - } - } - else{ - OutQueuePush(pack); - pack = 0; - } - } - base += size; - size = 7; - } - } - safe_delete(pack); - if (base != 0) { - if (base >= recvbuf_used) { - safe_delete_array(recvbuf); - } - else { - uchar* tmpbuf = new uchar[recvbuf_size - base]; - memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base); - safe_delete_array(recvbuf); - recvbuf = tmpbuf; - recvbuf_used -= base; - recvbuf_size -= base; - } - } - return true; -} - -bool TCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) { - sint32 base = 0; - sint32 size = 4; - uchar* buffer; - ServerPacket* pack = 0; - while ((recvbuf_used - base) >= size) { - buffer = &recvbuf[base]; - memcpy(&size, &buffer[2], 2); - if (size >= MaxTCPReceiveBufferSize) { -#if TCPN_DEBUG_Memory >= 1 - cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBufferSize" << endl; -#endif - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::ProcessReceivedDataAsPackets(): size >= MaxTCPReceiveBufferSize"); - return false; - } - if ((recvbuf_used - base) >= size) { - // ok, we got enough data to make this packet! - pack = new ServerPacket; - memcpy(&pack->opcode, &buffer[0], 2); - pack->size = size - 4; - - LogWrite(MISC__TODO, 1, "TODO", "Checksum or size check or something similar\n\t(%s, function: %s, line #: %i)", __FILE__, __FUNCTION__, __LINE__); - /* - if () { // TODO: Checksum or size check or something similar - // Datastream corruption, get the hell outta here! - delete pack; - return false; - } - */ - - if (pack->size > 0) { - pack->pBuffer = new uchar[pack->size]; - memcpy(pack->pBuffer, &buffer[4], pack->size); - } - if (pack->opcode == 0) { - // keepalive, no need to process - safe_delete(pack); - } - else { -#if TCPN_LOG_PACKETS >= 1 - if (pack && pack->opcode != 0) { - struct in_addr in; - in.s_addr = GetrIP(); - CoutTimestamp(true); - cout << ": Logging incoming TCP OldPacket. OPCode: 0x" << hex << setw(4) << setfill('0') << pack->opcode << dec << ", size: " << setw(5) << setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << endl; -#if TCPN_LOG_PACKETS == 2 - if (pack->size >= 32) - DumpPacket(pack->pBuffer, 32); - else - DumpPacket(pack); -#endif -#if TCPN_LOG_PACKETS >= 3 - DumpPacket(pack); -#endif - } -#endif - OutQueuePush(pack); - } - base += size; - size = 4; - } - } - if (base != 0) { - if (base >= recvbuf_used) { - safe_delete_array(recvbuf); - } - else { - uchar* tmpbuf = new uchar[recvbuf_size - base]; - memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base); - safe_delete_array(recvbuf); - recvbuf = tmpbuf; - recvbuf_used -= base; - recvbuf_size -= base; - } - } - return true; -} - -void TCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) { - int8 opcode = pack->pBuffer[0]; - - - /** disabling RELAY capabilities, this functionality is poorly implemented - even if such a feature needs to be re-used need authentication BEFORE allowing relay to take place - secondly we need to protect the LS accepting new connections as bogus data can be passed to open - fake TCP connections - opcode 0 is OK, that is Keep-Alive - **/ - - if (opcode > 0) - { - Disconnect(); - return; - } - - int8* data = &pack->pBuffer[1]; - switch (opcode) { - case 0: { - break; - } - case 1: { // Switch to RelayServer mode - if (pack->size != 1) { - SendNetErrorPacket("New RelayClient: wrong size, expected 1"); - break; - } - if (RelayServer) { - SendNetErrorPacket("Switch to RelayServer mode when already in RelayServer mode"); - break; - } - if (RemoteID) { - SendNetErrorPacket("Switch to RelayServer mode by a Relay Client"); - break; - } - if (ConnectionType != Incomming) { - SendNetErrorPacket("Switch to RelayServer mode on outgoing connection"); - break; - } -#if TCPC_DEBUG >= 3 - struct in_addr in; - in.s_addr = GetrIP(); - cout << "Switching to RelayServer mode: " << inet_ntoa(in) << ":" << GetPort() << endl; -#endif - RelayServer = true; - break; - } - case 2: { // New Relay Client - if (!RelayServer) { - SendNetErrorPacket("New RelayClient when not in RelayServer mode"); - break; - } - if (pack->size != 11) { - SendNetErrorPacket("New RelayClient: wrong size, expected 11"); - break; - } - if (ConnectionType != Incomming) { - SendNetErrorPacket("New RelayClient: illegal on outgoing connection"); - break; - } - TCPConnection* con = new TCPConnection(Server, this, *((int32*) data), *((int32*) &data[4]), *((int16*) &data[8])); - Server->AddConnection(con); - RelayCount++; - break; - } - case 3: { // Delete Relay Client - if (!RelayServer) { - SendNetErrorPacket("Delete RelayClient when not in RelayServer mode"); - break; - } - if (pack->size != 5) { - SendNetErrorPacket("Delete RelayClient: wrong size, expected 5"); - break; - } - TCPConnection* con = Server->GetConnection(*((int32*)data)); - if (con) { - if (ConnectionType == Incomming) { - if (con->GetRelayLink() != this) { - SendNetErrorPacket("Delete RelayClient: RelayLink != this"); - break; - } - } - con->Disconnect(false); - } - break; - } - case 255: { -#if TCPC_DEBUG >= 1 - struct in_addr in; - in.s_addr = GetrIP(); - cout "Received NetError: '"; - if (pack->size > 1) - cout << (char*) data; - cout << "': " << inet_ntoa(in) << ":" << GetPort() << endl; -#endif - break; - } - } -} - -void TCPConnection::SendNetErrorPacket(const char* reason) { -#if TCPC_DEBUG >= 1 - struct in_addr in; - in.s_addr = GetrIP(); - cout "NetError: '"; - if (reason) - cout << reason; - cout << "': " << inet_ntoa(in) << ":" << GetPort() << endl; -#endif - ServerPacket* pack = new ServerPacket(0); - pack->size = 1; - if (reason) - pack->size += strlen(reason) + 1; - pack->pBuffer = new uchar[pack->size]; - memset(pack->pBuffer, 0, pack->size); - pack->pBuffer[0] = 255; - strcpy((char*) &pack->pBuffer[1], reason); - SendPacket(pack); - safe_delete(pack); -} - -void TCPConnection::RemoveRelay(TCPConnection* relay, bool iSendRelayDisconnect) { - if (iSendRelayDisconnect) { - ServerPacket* pack = new ServerPacket(0, 5); - pack->pBuffer[0] = 3; - *((int32*) &pack->pBuffer[1]) = relay->GetRemoteID(); - SendPacket(pack); - safe_delete(pack); - } - RelayCount--; -} - -bool TCPConnection::SendData(char* errbuf) { - if (errbuf) - errbuf[0] = 0; - /************ Get first send packet on queue and send it! ************/ - uchar* data = 0; - sint32 size = 0; - int status = 0; - if (ServerSendQueuePop(&data, &size)) { -#ifdef WIN32 - status = send(connection_socket, (const char *) data, size, 0); -#else - status = send(connection_socket, data, size, MSG_NOSIGNAL); - if(errno==EPIPE) status = SOCKET_ERROR; -#endif - if (status >= 1) { -#if TCPN_LOG_RAW_DATA_OUT >= 1 - struct in_addr in; - in.s_addr = GetrIP(); - CoutTimestamp(true); - cout << ": Wrote " << status << " bytes to network. " << inet_ntoa(in) << ":" << GetrPort(); - if (pOldFormat) - cout << " (OldFormat)"; - cout << endl; -#if TCPN_LOG_RAW_DATA_OUT == 2 - sint32 tmp = status; - if (tmp > 32) - tmp = 32; - DumpPacket(data, status); -#elif TCPN_LOG_RAW_DATA_OUT >= 3 - DumpPacket(data, status); -#endif -#endif - keepalive_timer->Start(); - if (status < (signed)size) { -#if TCPN_LOG_RAW_DATA_OUT >= 1 - struct in_addr in; - in.s_addr = GetrIP(); - CoutTimestamp(true); - cout << ": Pushed " << (size - status) << " bytes back onto the send queue. " << inet_ntoa(in) << ":" << GetrPort(); - if (pOldFormat) - cout << " (OldFormat)"; - cout << endl; -#endif - // If there's network congestion, the number of bytes sent can be less than - // what we tried to give it... Push the extra back on the queue for later - ServerSendQueuePushFront(&data[status], size - status); - } - else if (status > (signed)size) { - ThrowError("TCPConnection::SendData(): WTF! status > size"); - return false; - } - // else if (status == size) {} - } - else { - ServerSendQueuePushFront(data, size); - } - - safe_delete_array(data); - if (status == SOCKET_ERROR) { -#ifdef WIN32 - if (WSAGetLastError() != WSAEWOULDBLOCK) -#else - if (errno != EWOULDBLOCK) -#endif - { - if (errbuf) { -#ifdef WIN32 - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::SendData(): send(): Errorcode: %i", WSAGetLastError()); -#else - snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::SendData(): send(): Errorcode: %s", strerror(errno)); -#endif - } - return false; - } - } - } - if (TCPMode == modePacket && keepalive_timer->Check()) { - ServerPacket* pack = new ServerPacket(0, 0); - SendPacket(pack); - safe_delete(pack); -#if TCPN_DEBUG >= 5 - cout << "Sending TCP keepalive packet. (timeout=" << timeout_timer->GetRemainingTime() << " remaining)" << endl; -#endif - } - return true; -} - -ThreadReturnType TCPConnectionLoop(void* tmp) { -#ifdef WIN32 - SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); -#endif - if (tmp == 0) { - ThrowError("TCPConnectionLoop(): tmp = 0!"); - THREAD_RETURN(NULL); - } - TCPConnection* tcpc = (TCPConnection*) tmp; - tcpc->MLoopRunning.lock(); - while (tcpc->RunLoop()) { - Sleep(LOOP_GRANULARITY); - if (tcpc->GetState() != TCPS_Ready) { - if (!tcpc->Process()) { - tcpc->Disconnect(); - } - } - else if (tcpc->GetAsyncConnect()) { - if (tcpc->charAsyncConnect) - tcpc->Connect(tcpc->charAsyncConnect, tcpc->GetrPort()); - else - tcpc->Connect(tcpc->GetrIP(), tcpc->GetrPort()); - tcpc->SetAsyncConnect(false); - } - else - Sleep(10); - } - tcpc->MLoopRunning.unlock(); - - THREAD_RETURN(NULL); -} - -bool TCPConnection::RunLoop() { - bool ret; - MRunLoop.lock(); - ret = pRunLoop; - MRunLoop.unlock(); - return ret; -} - - - - - -TCPServer::TCPServer(int16 in_port, bool iOldFormat) { - NextID = 1; - pPort = in_port; - sock = 0; - pOldFormat = iOldFormat; - list = new LinkedList; - pRunLoop = true; -#ifdef WIN32 - _beginthread(TCPServerLoop, 0, this); -#else - pthread_t thread; - pthread_create(&thread, NULL, &TCPServerLoop, this); - pthread_detach(thread); -#endif -} - -TCPServer::~TCPServer() { - MRunLoop.lock(); - pRunLoop = false; - MRunLoop.unlock(); - MLoopRunning.lock(); - MLoopRunning.unlock(); - - while (NewQueue.pop()); // the objects are deleted with the list, clear this queue so it doesnt try to delete them again - safe_delete(list); -} - -bool TCPServer::RunLoop() { - bool ret; - MRunLoop.lock(); - ret = pRunLoop; - MRunLoop.unlock(); - return ret; -} - -ThreadReturnType TCPServerLoop(void* tmp) { -#ifdef WIN32 - SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); -#endif - if (tmp == 0) { - ThrowError("TCPServerLoop(): tmp = 0!"); - THREAD_RETURN(NULL); - } - TCPServer* tcps = (TCPServer*) tmp; - tcps->MLoopRunning.lock(); - while (tcps->RunLoop()) { - Sleep(SERVER_LOOP_GRANULARITY); - tcps->Process(); - } - tcps->MLoopRunning.unlock(); - - THREAD_RETURN(NULL); -} - -void TCPServer::Process() { - CheckInQueue(); - ListenNewConnections(); - LinkedListIterator iterator(*list); - - iterator.Reset(); - while(iterator.MoreElements()) { - if (iterator.GetData()->IsFree() && (!iterator.GetData()->CheckNetActive())) { -#if _DEBUG - LogWrite(NET__DEBUG, 0, "Net", "EQStream Connection deleted."); -#endif - iterator.RemoveCurrent(); - } - else { - if (!iterator.GetData()->Process()) - iterator.GetData()->Disconnect(); - iterator.Advance(); - } - } -} - -void TCPServer::ListenNewConnections() { - SOCKET tmpsock; - struct sockaddr_in from; - struct in_addr in; - unsigned int fromlen; - - TCPConnection* con; - - from.sin_family = AF_INET; - fromlen = sizeof(from); - LockMutex lock(&MSock); - if (!sock) - return; - - // Check for pending connects -#ifdef WIN32 - unsigned long nonblocking = 1; - while ((tmpsock = accept(sock, (struct sockaddr*) &from, (int *) &fromlen)) != INVALID_SOCKET) { - ioctlsocket (tmpsock, FIONBIO, &nonblocking); -#else - while ((tmpsock = accept(sock, (struct sockaddr*) &from, &fromlen)) != INVALID_SOCKET) { - fcntl(tmpsock, F_SETFL, O_NONBLOCK); -#endif - int bufsize = 64 * 1024; // 64kbyte recieve buffer, up from default of 8k - setsockopt(tmpsock, SOL_SOCKET, SO_RCVBUF, (char*) &bufsize, sizeof(bufsize)); - in.s_addr = from.sin_addr.s_addr; - - // New TCP connection - con = new TCPConnection(this, tmpsock, in.s_addr, ntohs(from.sin_port), pOldFormat); -#if TCPN_DEBUG >= 1 - cout << "New TCP connection: " << inet_ntoa(in) << ":" << con->GetrPort() << endl; -#endif - AddConnection(con); - } -} - -bool TCPServer::Open(int16 in_port, char* errbuf) { - if (errbuf) - errbuf[0] = 0; - LockMutex lock(&MSock); - if (sock != 0) { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "Listening socket already open"); - return false; - } - if (in_port != 0) { - pPort = in_port; - } - -#ifdef WIN32 - SOCKADDR_IN address; - unsigned long nonblocking = 1; -#else - struct sockaddr_in address; -#endif - int reuse_addr = 1; - - // Setup internet address information. - // This is used with the bind() call - memset((char *) &address, 0, sizeof(address)); - address.sin_family = AF_INET; - address.sin_port = htons(pPort); - address.sin_addr.s_addr = htonl(INADDR_ANY); - - // Setting up TCP port for new TCP connections - sock = socket(AF_INET, SOCK_STREAM, 0); - if (sock == INVALID_SOCKET) { - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "socket(): INVALID_SOCKET"); - return false; - } - - // Quag: dont think following is good stuff for TCP, good for UDP - // Mis: SO_REUSEADDR shouldn't be a problem for tcp--allows you to restart - // without waiting for conns in TIME_WAIT to die - setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &reuse_addr, sizeof(reuse_addr)); - - - if (::bind(sock, (struct sockaddr *) &address, sizeof(address)) < 0) { -#ifdef WIN32 - closesocket(sock); -#else - close(sock); -#endif - sock = 0; - if (errbuf) - sprintf(errbuf, "bind(): <0"); - return false; - } - - int bufsize = 64 * 1024; // 64kbyte recieve buffer, up from default of 8k - setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*) &bufsize, sizeof(bufsize)); -#ifdef WIN32 - ioctlsocket (sock, FIONBIO, &nonblocking); -#else - fcntl(sock, F_SETFL, O_NONBLOCK); -#endif - - if (listen(sock, SOMAXCONN) == SOCKET_ERROR) { -#ifdef WIN32 - closesocket(sock); - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "listen() failed, Error: %d", WSAGetLastError()); -#else - close(sock); - if (errbuf) - snprintf(errbuf, TCPConnection_ErrorBufferSize, "listen() failed, Error: %s", strerror(errno)); -#endif - sock = 0; - return false; - } - - return true; -} - -void TCPServer::Close() { - LockMutex lock(&MSock); - if (sock) { -#ifdef WIN32 - closesocket(sock); -#else - close(sock); -#endif - } - sock = 0; -} - -bool TCPServer::IsOpen() { - MSock.lock(); - bool ret = (bool) (sock != 0); - MSock.unlock(); - return ret; -} - -TCPConnection* TCPServer::NewQueuePop() { - TCPConnection* ret; - MNewQueue.lock(); - ret = NewQueue.pop(); - MNewQueue.unlock(); - return ret; -} - -void TCPServer::AddConnection(TCPConnection* con) { - list->Append(con); - MNewQueue.lock(); - NewQueue.push(con); - MNewQueue.unlock(); -} - -TCPConnection* TCPServer::GetConnection(int32 iID) { - LinkedListIterator iterator(*list); - - iterator.Reset(); - while(iterator.MoreElements()) { - if (iterator.GetData()->GetID() == iID) - return iterator.GetData(); - iterator.Advance(); - } - return 0; -} - -void TCPServer::SendPacket(ServerPacket* pack) { - TCPConnection::TCPNetPacket_Struct* tnps = TCPConnection::MakePacket(pack); - SendPacket(&tnps); -} - -void TCPServer::SendPacket(TCPConnection::TCPNetPacket_Struct** tnps) { - MInQueue.lock(); - InQueue.push(*tnps); - MInQueue.unlock(); - tnps = 0; -} - -void TCPServer::CheckInQueue() { - LinkedListIterator iterator(*list); - TCPConnection::TCPNetPacket_Struct* tnps = 0; - - while (( tnps = InQueuePop() )) { - iterator.Reset(); - while(iterator.MoreElements()) { - if (iterator.GetData()->GetMode() != modeConsole && iterator.GetData()->GetRemoteID() == 0) - iterator.GetData()->SendPacket(tnps); - iterator.Advance(); - } - safe_delete(tnps); - } -} - -TCPConnection::TCPNetPacket_Struct* TCPServer::InQueuePop() { - TCPConnection::TCPNetPacket_Struct* ret; - MInQueue.lock(); - ret = InQueue.pop(); - MInQueue.unlock(); - return ret; -} - - diff --git a/source/common/TCPConnection.h b/source/common/TCPConnection.h deleted file mode 100644 index ae47526..0000000 --- a/source/common/TCPConnection.h +++ /dev/null @@ -1,277 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef TCP_CONNECTION_H -#define TCP_CONNECTION_H -/* - Parent classes for interserver TCP Communication. - -Quagmire -*/ - -#ifdef WIN32 - #define snprintf _snprintf - #define vsnprintf _vsnprintf - #define strncasecmp _strnicmp - #define strcasecmp _stricmp - - #include -#else - #include - #include - #include - #include - #include - #include - #include - #include - #define INVALID_SOCKET -1 - #define SOCKET_ERROR -1 - #include "unix.h" - -#endif - -#include "types.h" -#include "Mutex.h" -#include "linked_list.h" -#include "queue.h" -#include "servertalk.h" -#include "timer.h" -#include "MiscFunctions.h" - -class TCPServer; - -#define TCPConnection_ErrorBufferSize 1024 -#define MaxTCPReceiveBufferSize 524288 - -#define TCPS_Ready 0 -#define TCPS_Connecting 1 -#define TCPS_Connected 100 -#define TCPS_Disconnecting 200 -#define TCPS_Disconnected 201 -#define TCPS_Closing 250 -#define TCPS_Error 255 - -#ifndef DEF_eConnectionType -#define DEF_eConnectionType -enum eConnectionType {Incomming, Outgoing}; -#endif - -#ifdef WIN32 - void TCPServerLoop(void* tmp); - void TCPConnectionLoop(void* tmp); -#else - void* TCPServerLoop(void* tmp); - void* TCPConnectionLoop(void* tmp); -#endif - -enum eTCPMode { modeConsole, modeTransition, modePacket }; -class TCPConnection { -public: -#pragma pack(1) - struct TCPNetPacket_Struct { - int32 size; - struct { - int8 - compressed : 1, - destination : 1, - flag3 : 1, - flag4 : 1, - flag5 : 1, - flag6 : 1, - flag7 : 1, - flag8 : 1; - } flags; - int16 opcode; - uchar buffer[0]; - }; -#pragma pack() - - static TCPNetPacket_Struct* MakePacket(ServerPacket* pack, int32 iDestination = 0); - - TCPConnection(TCPServer* iServer, SOCKET iSock, int32 irIP, int16 irPort, bool iOldFormat = false); - TCPConnection(bool iOldFormat = false, TCPServer* iRelayServer = 0, eTCPMode iMode = modePacket); // for outgoing connections - TCPConnection(TCPServer* iServer, TCPConnection* iRelayLink, int32 iRemoteID, int32 irIP, int16 irPort); // for relay connections - virtual ~TCPConnection(); - - // Functions for outgoing connections - bool Connect(char* irAddress, int16 irPort, char* errbuf = 0); - bool Connect(int32 irIP, int16 irPort, char* errbuf = 0); - void AsyncConnect(char* irAddress, int16 irPort); - void AsyncConnect(int32 irIP, int16 irPort); - virtual void Disconnect(bool iSendRelayDisconnect = true); - - virtual bool SendPacket(ServerPacket* pack, int32 iDestination = 0); - virtual bool SendPacket(TCPNetPacket_Struct* tnps); - bool Send(const uchar* data, sint32 size); - - char* PopLine(); - ServerPacket* PopPacket(); // OutQueuePop() - inline int32 GetrIP() { return rIP; } - inline int16 GetrPort() { return rPort; } - virtual int8 GetState(); - eTCPMode GetMode() { return TCPMode; } - inline bool Connected() { return (GetState() == TCPS_Connected); } - inline bool ConnectReady() { return (bool) (GetState() == TCPS_Ready && ConnectionType == Outgoing); } - void Free(); // Inform TCPServer that this connection object is no longer referanced - - inline int32 GetID() { return id; } - inline bool IsRelayServer() { return RelayServer; } - inline int32 GetRemoteID() { return RemoteID; } - inline TCPConnection* GetRelayLink() { return RelayLink; } - - bool GetEcho(); - void SetEcho(bool iValue); -protected: - friend class TCPServer; - virtual bool Process(); - void SetState(int8 iState); - inline bool IsFree() { return pFree; } - bool CheckNetActive(); - -#ifdef WIN32 - friend void TCPConnectionLoop(void* tmp); -#else - friend void* TCPConnectionLoop(void* tmp); -#endif - SOCKET sock; - bool RunLoop(); - Mutex MLoopRunning; - Mutex MAsyncConnect; - bool GetAsyncConnect(); - bool SetAsyncConnect(bool iValue); - char* charAsyncConnect; - -#ifdef WIN32 - friend class TCPConnection; -#endif - void OutQueuePush(ServerPacket* pack); - void RemoveRelay(TCPConnection* relay, bool iSendRelayDisconnect); -private: - void ProcessNetworkLayerPacket(ServerPacket* pack); - void SendNetErrorPacket(const char* reason = 0); - TCPServer* Server; - TCPConnection* RelayLink; - int32 RemoteID; - sint32 RelayCount; - - bool pOldFormat; - bool SendData(char* errbuf = 0); - bool RecvData(char* errbuf = 0); - bool ProcessReceivedData(char* errbuf = 0); - bool ProcessReceivedDataAsPackets(char* errbuf = 0); - bool ProcessReceivedDataAsOldPackets(char* errbuf = 0); - void ClearBuffers(); - - bool pAsyncConnect; - - eConnectionType ConnectionType; - eTCPMode TCPMode; - bool RelayServer; - Mutex MRunLoop; - bool pRunLoop; - - SOCKET connection_socket; - int32 id; - int32 rIP; - int16 rPort; // host byte order - bool pFree; - - Mutex MState; - int8 pState; - - void LineOutQueuePush(char* line); - MyQueue LineOutQueue; - MyQueue OutQueue; - Mutex MOutQueueLock; - - Timer* keepalive_timer; - Timer* timeout_timer; - - uchar* recvbuf; - sint32 recvbuf_size; - sint32 recvbuf_used; - - sint32 recvbuf_echo; - bool pEcho; - Mutex MEcho; - - void InModeQueuePush(TCPNetPacket_Struct* tnps); - MyQueue InModeQueue; - Mutex MSendQueue; - uchar* sendbuf; - sint32 sendbuf_size; - sint32 sendbuf_used; - bool ServerSendQueuePop(uchar** data, sint32* size); - void ServerSendQueuePushEnd(const uchar* data, sint32 size); - void ServerSendQueuePushEnd(uchar** data, sint32 size); - void ServerSendQueuePushFront(uchar* data, sint32 size); -}; - -class TCPServer { -public: - TCPServer(int16 iPort = 0, bool iOldFormat = false); - virtual ~TCPServer(); - - bool Open(int16 iPort = 0, char* errbuf = 0); // opens the port - void Close(); // closes the port - bool IsOpen(); - inline int16 GetPort() { return pPort; } - - TCPConnection* NewQueuePop(); - - void SendPacket(ServerPacket* pack); - void SendPacket(TCPConnection::TCPNetPacket_Struct** tnps); -protected: -#ifdef WIN32 - friend void TCPServerLoop(void* tmp); -#else - friend void* TCPServerLoop(void* tmp); -#endif - void Process(); - bool RunLoop(); - Mutex MLoopRunning; - - friend class TCPConnection; - inline int32 GetNextID() { return NextID++; } - void AddConnection(TCPConnection* con); - TCPConnection* GetConnection(int32 iID); -private: - void ListenNewConnections(); - - int32 NextID; - bool pOldFormat; - - Mutex MRunLoop; - bool pRunLoop; - - Mutex MSock; - SOCKET sock; - int16 pPort; - - Mutex MNewQueue; - MyQueue NewQueue; - - void CheckInQueue(); - Mutex MInQueue; - TCPConnection::TCPNetPacket_Struct* InQueuePop(); - MyQueue InQueue; - - LinkedList* list; -}; -#endif diff --git a/source/common/database.cpp b/source/common/database.cpp deleted file mode 100644 index 9a88a5e..0000000 --- a/source/common/database.cpp +++ /dev/null @@ -1,567 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "../common/debug.h" - -#include -using namespace std; -#include -#include -#include -#include -//#include -#include -#include -#include -#include - -// Disgrace: for windows compile -#ifdef WIN32 -#include -#include -#define snprintf _snprintf -#define strncasecmp _strnicmp -#define strcasecmp _stricmp -#else -#include "unix.h" -#include -#endif - -#include "database.h" -#include "EQStream.h" -#include "packet_functions.h" -#include "emu_opcodes.h" -#ifdef WORLD - #include "../WorldServer/WorldDatabase.h" - extern WorldDatabase database; -#endif -#ifdef LOGIN - #include "../LoginServer/LoginDatabase.h" - extern LoginDatabase database; -#endif -#ifdef PARSER - #include "../PacketParser/ParserDatabase.h" - extern ParserDatabase database; -#endif - -#ifdef PATCHER - #include "../PatchServer/PatcherDatabase.h" - extern PatcherDatabase database; -#endif -#include "../common/EQEMuError.h" -#include "../common/packet_dump.h" -#include "../common/Log.h" - -#ifdef WORLD -ThreadReturnType DBAsyncQueries(void* str) -{ - // allow some buffer for multiple queries to collect - Sleep(10); - DBStruct* data = (DBStruct*)str; - database.RunAsyncQueries(data->queryid); - delete data; - THREAD_RETURN(NULL); -} -#endif - -Database::Database() -{ - InitVars(); -} - -bool Database::Init(bool silentLoad) { - char host[200], user[200], passwd[200], database[200]; - unsigned int port=0; - bool compression = false; - bool items[6] = {false, false, false, false, false, false}; - const char* exampleIni[] = { "[Database]", "host = localhost", "user = root", "password = pass", "database = dbname", "### --- Assure each parameter is on a new line!" }; - - if(!ReadDBINI(host, user, passwd, database, &port, &compression, items)) { - //exit(1); - return false; - } - - if (!items[0] || !items[1] || !items[2] || !items[3]) - { - LogWrite(DATABASE__ERROR, 0, "DB", "Database file %s is incomplete.", DB_INI_FILE); - int i; - for (i = 0; i < 4; i++) - { - if ( !items[i] ) - LogWrite(DATABASE__ERROR, 0, "DB", "Could not find parameter %s", exampleIni[i+1]); // offset by 1 because the [Database] entry - } - LogWrite(DATABASE__ERROR, 0, "DB", "Example File:"); - int length = sizeof exampleIni / sizeof exampleIni[0]; - for(i=0;i Database::GetVersions(){ - map opcodes; - Query query; - MYSQL_ROW row; - MYSQL_RES* result = query.RunQuery2(Q_SELECT, "select distinct version_range1, version_range2 from opcodes"); - while(result && (row = mysql_fetch_row(result))){ - if(row[0] && row[1]) - opcodes[atoi(row[0])] = atoi(row[1]); - } - return opcodes; -} - -map Database::GetOpcodes(int16 version){ - map opcodes; - Query query; - MYSQL_ROW row; - MYSQL_RES* result = query.RunQuery2(Q_SELECT, "select name, opcode from opcodes where %i between version_range1 and version_range2 order by version_range1, id", version); - while(result && (row = mysql_fetch_row(result))){ - opcodes[row[0]] = atoi(row[1]); - } - return opcodes; -} - -int32 Database::AuthenticateWebUser(char* userName, char* passwd, int32* status){ - if(status) { - *status = 0; - } - Query query; - MYSQL_ROW row; - int32 id = 0; - MYSQL_RES* result = query.RunQuery2(Q_SELECT, "select id, status from web_users where username='%s' and passwd = sha2('%s', 512)", getSafeEscapeString(userName).c_str(), getSafeEscapeString(passwd).c_str()); - if(result && (row = mysql_fetch_row(result))){ - id = atoul(row[0]); - if(status) { - *status = atoul(row[1]); - } - } - return id; -} - -int32 Database::NoAuthRoute(char* route){ - Query query; - MYSQL_ROW row; - int32 status = 0xFFFFFFFF; - MYSQL_RES* result = query.RunQuery2(Q_SELECT, "select status from web_routes where route='%s'", getSafeEscapeString(route).c_str()); - if(result && (row = mysql_fetch_row(result))){ - status = atoul(row[0]); - } - return status; -} - -void Database::HandleMysqlError(int32 errnum) { - switch(errnum) { - case 0: - break; - case 1045: // Access Denied - case 2001: { - AddEQEMuError(EQEMuError_Mysql_1405, true); - break; - } - case 2003: { // Unable to connect - AddEQEMuError(EQEMuError_Mysql_2003, true); - break; - } - case 2005: { // Unable to connect - AddEQEMuError(EQEMuError_Mysql_2005, true); - break; - } - case 2007: { // Unable to connect - AddEQEMuError(EQEMuError_Mysql_2007, true); - break; - } - } -} - -void Database::InitVars() { - -} - -Database::~Database() -{ -#ifdef WORLD - DBQueryMutex.writelock(__FUNCTION__, __LINE__); - activeQuerySessions.clear(); - DBQueryMutex.releasewritelock(__FUNCTION__, __LINE__); - - DBAsyncMutex.writelock(); - continueAsync = false; - map>::iterator itr; - for (itr = asyncQueries.begin(); itr != asyncQueries.end(); itr++) - { - asyncQueriesMutex[itr->first]->writelock(); - deque queries = itr->second; - while (queries.size() > 0) - { - Query* cur = queries.front(); - queries.pop_front(); - safe_delete(cur); - } - asyncQueriesMutex[itr->first]->releasewritelock(); - Mutex* mutex = asyncQueriesMutex[itr->first]; - asyncQueriesMutex.erase(itr->first); - safe_delete(mutex); - } - asyncQueries.clear(); - - asyncQueriesMutex.clear(); - DBAsyncMutex.releasewritelock(); - - PurgeDBInstances(); -#endif -} - -#ifdef WORLD -void Query::AddQueryAsync(int32 queryID, Database* db, QUERY_TYPE type, const char* format, ...) { - in_type = type; - va_list args; - va_start(args, format); -#ifdef WIN32 - char* buffer; - int buf_len = _vscprintf(format, args) + 1; - buffer = new char[buf_len]; - vsprintf(buffer, format, args); -#else - char* buffer; - int buf_len; - va_list argcopy; - va_copy(argcopy, args); - buf_len = vsnprintf(NULL, 0, format, argcopy) + 1; - va_end(argcopy); - - buffer = new char[buf_len]; - vsnprintf(buffer, buf_len, format, args); -#endif - va_end(args); - query = string(buffer); - - Query* asyncQuery = new Query(this, queryID); - - safe_delete_array(buffer); - - db->AddAsyncQuery(asyncQuery); -} - -void Query::RunQueryAsync(Database* db) { - db->RunQuery(query.c_str(), query.length(), errbuf, &result, affected_rows, last_insert_id, &errnum, retry); -} -#endif - -MYSQL_RES* Query::RunQuery2(QUERY_TYPE type, const char* format, ...){ - va_list args; - va_start( args, format ); - #ifdef WIN32 - char * buffer; - int buf_len = _vscprintf( format, args ) + 1; - buffer = new char[buf_len]; - vsprintf( buffer, format, args ); - #else - char* buffer; - int buf_len; - va_list argcopy; - va_copy(argcopy, args); - buf_len = vsnprintf(NULL, 0, format, argcopy) + 1; - va_end(argcopy); - - buffer = new char[buf_len]; - vsnprintf(buffer, buf_len, format, args); - #endif - va_end(args); - query = string(buffer); - - - safe_delete_array( buffer ); - - - return RunQuery2(query.c_str(), type); -} -MYSQL_RES* Query::RunQuery2(string in_query, QUERY_TYPE type){ - switch(type){ - case Q_SELECT: - break; - case Q_DBMS: - case Q_REPLACE: - case Q_DELETE: - case Q_UPDATE: - safe_delete(affected_rows); - affected_rows = new int32; - break; - case Q_INSERT: - safe_delete(last_insert_id); - last_insert_id = new int32; - } - if(result){ - if(!multiple_results) - multiple_results = new vector(); - multiple_results->push_back(result); - } - query = in_query; - -#if defined WORLD && defined _DEBUG - if (type == Q_UPDATE || type == Q_INSERT || type == Q_DELETE || type == Q_REPLACE) - { - char* filteredTables[] = { " characters", " character_", " `character_", " statistics", " variables", " char_colors", " `guild", " bugs" }; - - bool match = false; - for (int i = 0; i < sizeof(filteredTables) / sizeof(filteredTables[0]); i++) - { - if (query.find(filteredTables[i]) != std::string::npos) { - match = true; - break; - } - } - try - { - if (!match) - { - FILE* pFile; - pFile = fopen("sql_updates.sql", "a+"); - fwrite(query.c_str(), 1, query.length(), pFile); - fwrite(";", sizeof(char), 1, pFile); - fwrite("\n", sizeof(char), 1, pFile); - fclose(pFile); - } - } - catch (...) {} - } -#endif - - - database.RunQuery(query.c_str(), query.length(), errbuf, &result, affected_rows, last_insert_id, &errnum, retry); - return result; -} - -#ifdef WORLD -void Database::RunAsyncQueries(int32 queryid) -{ - Database* asyncdb = FindFreeInstance(); - DBAsyncMutex.writelock(); - map>::iterator itr = asyncQueries.find(queryid); - if (itr == asyncQueries.end()) - { - DBAsyncMutex.releasewritelock(); - return; - } - - asyncQueriesMutex[queryid]->writelock(); - deque queries; - while (itr->second.size()) - { - Query* cur = itr->second.front(); - queries.push_back(cur); - itr->second.pop_front(); - } - itr->second.clear(); - asyncQueries.erase(itr); - DBAsyncMutex.releasewritelock(); - asyncQueriesMutex[queryid]->releasewritelock(); - - int32 count = 0; - while (queries.size() > 0) - { - Query* cur = queries.front(); - cur->RunQueryAsync(asyncdb); - this->RemoveActiveQuery(cur); - queries.pop_front(); - safe_delete(cur); - } - FreeDBInstance(asyncdb); - - bool isActive = IsActiveQuery(queryid); - if (isActive) - { - continueAsync = true; - DBStruct* tmp = new DBStruct; - tmp->queryid = queryid; -#ifdef WIN32 - _beginthread(DBAsyncQueries, 0, (void*)tmp); -#else - pthread_t t1; - pthread_create(&t1, NULL, DBAsyncQueries, (void*)tmp); - pthread_detach(t1); -#endif - } -} - -void Database::AddAsyncQuery(Query* query) -{ - DBAsyncMutex.writelock(); - map::iterator mutexItr = asyncQueriesMutex.find(query->GetQueryID()); - if (mutexItr == asyncQueriesMutex.end()) - { - Mutex* queryMutex = new Mutex(); - queryMutex->SetName("AsyncQuery" + query->GetQueryID()); - asyncQueriesMutex.insert(make_pair(query->GetQueryID(), queryMutex)); - } - map>::iterator itr = asyncQueries.find(query->GetQueryID()); - asyncQueriesMutex[query->GetQueryID()]->writelock(); - - if ( itr != asyncQueries.end()) - itr->second.push_back(query); - else - { - deque queue; - queue.push_back(query); - asyncQueries.insert(make_pair(query->GetQueryID(), queue)); - } - - AddActiveQuery(query); - - asyncQueriesMutex[query->GetQueryID()]->releasewritelock(); - DBAsyncMutex.releasewritelock(); - - bool isActive = IsActiveQuery(query->GetQueryID(), query); - if (!isActive) - { - continueAsync = true; - DBStruct* tmp = new DBStruct; - tmp->queryid = query->GetQueryID(); -#ifdef WIN32 - _beginthread(DBAsyncQueries, 0, (void*)tmp); -#else - pthread_t t1; - pthread_create(&t1, NULL, DBAsyncQueries, (void*)tmp); - pthread_detach(t1); -#endif - } -} - -Database* Database::FindFreeInstance() -{ - Database* db_inst = 0; - map::iterator itr; - DBInstanceMutex.writelock(__FUNCTION__, __LINE__); - for (itr = dbInstances.begin(); itr != dbInstances.end(); itr++) { - if (!itr->second) - { - db_inst = itr->first; - itr->second = true; - break; - } - } - - if (!db_inst) - { - WorldDatabase* tmp = new WorldDatabase(); - db_inst = (Database*)tmp; - tmp->Init(); - tmp->ConnectNewDatabase(); - dbInstances.insert(make_pair(db_inst, true)); - } - DBInstanceMutex.releasewritelock(__FUNCTION__, __LINE__); - - return db_inst; -} - -void Database::PurgeDBInstances() -{ - map::iterator itr; - DBInstanceMutex.writelock(__FUNCTION__, __LINE__); - for (itr = dbInstances.begin(); itr != dbInstances.end(); itr++) { - WorldDatabase* tmpInst = (WorldDatabase*)itr->first; - safe_delete(tmpInst); - } - dbInstances.clear(); - DBInstanceMutex.releasewritelock(__FUNCTION__, __LINE__); -} - - -void Database::PingAsyncDatabase() -{ - map::iterator itr; - DBInstanceMutex.readlock(__FUNCTION__, __LINE__); - for (itr = dbInstances.begin(); itr != dbInstances.end(); itr++) { - Database* tmpInst = itr->first; - tmpInst->ping(); - } - DBInstanceMutex.releasereadlock(__FUNCTION__, __LINE__); -} - -void Database::FreeDBInstance(Database* cur) -{ - DBInstanceMutex.writelock(__FUNCTION__, __LINE__); - dbInstances[cur] = false; - DBInstanceMutex.releasewritelock(__FUNCTION__, __LINE__); -} - -void Database::RemoveActiveQuery(Query* query) -{ - DBQueryMutex.writelock(__FUNCTION__, __LINE__); - - vector::iterator itr; - for (itr = activeQuerySessions.begin(); itr != activeQuerySessions.end(); itr++) - { - Query* curQuery = *itr; - if (query == curQuery) - { - activeQuerySessions.erase(itr); - break; - } - } - DBQueryMutex.releasewritelock(__FUNCTION__, __LINE__); -} - -void Database::AddActiveQuery(Query* query) -{ - DBQueryMutex.writelock(__FUNCTION__, __LINE__); - activeQuerySessions.push_back(query); - DBQueryMutex.releasewritelock(__FUNCTION__, __LINE__); -} - -bool Database::IsActiveQuery(int32 id, Query* skip) -{ - bool isActive = false; - - DBQueryMutex.readlock(__FUNCTION__, __LINE__); - vector::iterator itr; - for (itr = activeQuerySessions.begin(); itr != activeQuerySessions.end(); itr++) - { - Query* query = *itr; - if (query == skip) - continue; - - if (query->GetQueryID() == id) - { - isActive = true; - break; - } - } - DBQueryMutex.releasereadlock(__FUNCTION__, __LINE__); - - return isActive; -} -#endif \ No newline at end of file diff --git a/source/common/database.h b/source/common/database.h deleted file mode 100644 index 4a5fbd2..0000000 --- a/source/common/database.h +++ /dev/null @@ -1,183 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef EQ2EMU_DATABASE_H -#define EQ2EMU_DATABASE_H - -#ifdef WIN32 - #include - #include -#endif -#include - -#include "dbcore.h" -#include "types.h" -#include "linked_list.h" -#include "EQStream.h" -#include "MiscFunctions.h" -#include "Mutex.h" -#include -#include -#include - -using namespace std; -class Query; - -class Database : public DBcore -{ -public: - Database(); - ~Database(); - bool Init(bool silentLoad=false); - bool LoadVariables(); - void HandleMysqlError(int32 errnum); - map GetOpcodes(int16 version); - int32 AuthenticateWebUser(char* userName, char* passwd,int32* status = 0); - int32 NoAuthRoute(char* route); - map GetVersions(); - -#ifdef WORLD - void AddAsyncQuery(Query* query); - void RunAsyncQueries(int32 queryid); - Database* FindFreeInstance(); - void RemoveActiveQuery(Query* query); - void AddActiveQuery(Query* query); - bool IsActiveQuery(int32 id, Query* skip=0); - void PingAsyncDatabase(); -#endif -protected: - -private: - void InitVars(); - -#ifdef WORLD - void PurgeDBInstances(); - void FreeDBInstance(Database* cur); - bool continueAsync; - map> asyncQueries; - map asyncQueriesMutex; - map dbInstances; - vector activeQuerySessions; - Mutex DBAsyncMutex; - Mutex DBInstanceMutex; - Mutex DBQueryMutex; -#endif -}; - -typedef struct { - int32 queryid; -}DBStruct; - -class Query{ -public: - Query() { - result = 0; - affected_rows = 0; - last_insert_id = 0; - errnum = 0; - row = 0; - retry = true; - escaped_name = 0; - escaped_pass = 0; - escaped_data1 = 0; - multiple_results = 0; - memset(errbuf, 0, sizeof(errbuf)); - queryID = 0; - } - Query(Query* queryPtr, int32 in_id) { - result = 0; - affected_rows = 0; - last_insert_id = 0; - errnum = 0; - row = 0; - retry = true; - escaped_name = 0; - escaped_pass = 0; - escaped_data1 = 0; - multiple_results = 0; - memset(errbuf, 0, sizeof(errbuf)); - query = string(queryPtr->GetQuery()); - in_type = queryPtr->GetQueryType(); - queryID = in_id; - } - - ~Query(){ - if(result) - mysql_free_result(result); - result = 0; - safe_delete(affected_rows); - safe_delete(last_insert_id); - safe_delete_array(escaped_name); - safe_delete_array(escaped_pass); - safe_delete_array(escaped_data1); - if(multiple_results){ - vector::iterator itr; - for(itr = multiple_results->begin(); itr != multiple_results->end(); itr++){ - mysql_free_result(*itr); - } - safe_delete(multiple_results); - } - } - int32 GetLastInsertedID() { return *last_insert_id; } - int32 GetAffectedRows() { return *affected_rows; } - MYSQL_RES* GetResult() { return result; } - MYSQL_RES* RunQuery2(string in_query, QUERY_TYPE type); - char* GetError() { return errbuf; } - int32 GetErrorNumber(){ return errnum; } - const char* GetQuery() { return query.c_str(); } - char* GetField(int8 field_num) { - if(!row && result) - *row = mysql_fetch_row(result); - if(row && result && field_num < mysql_num_fields(result)) - return *row[field_num]; - else - return NULL; - } - void NextRow(){ - if(result) - *row = mysql_fetch_row(result); - } - void AddQueryAsync(int32 queryID, Database* db, QUERY_TYPE type, const char* format, ...); - void RunQueryAsync(Database* db); - MYSQL_RES* RunQuery2(QUERY_TYPE type, const char* format, ...); - - QUERY_TYPE GetQueryType() { - return in_type; - } - - int32 GetQueryID() { return queryID; } - - char* escaped_name; - char* escaped_pass; - char* escaped_data1; -private: - string query; - char errbuf[MYSQL_ERRMSG_SIZE]; - MYSQL_RES *result; - vector* multiple_results; - int32* affected_rows; - int32* last_insert_id; - int32 errnum; - QUERY_TYPE in_type; - bool retry; - MYSQL_ROW* row; - MYSQL mysql; - int32 queryID; -}; -#endif diff --git a/source/common/dbcore.cpp b/source/common/dbcore.cpp deleted file mode 100644 index e200e9d..0000000 --- a/source/common/dbcore.cpp +++ /dev/null @@ -1,368 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "debug.h" - -#include -using namespace std; -#include -//#include -#include -#include "dbcore.h" -#include -#include -#include -#include "types.h" -#include "MiscFunctions.h" -#include "Log.h" - -#ifdef WIN32 - #define snprintf _snprintf - #define strncasecmp _strnicmp - #define strcasecmp _stricmp - #include -#else - #include "unix.h" - #include -#endif - -#ifdef _EQDEBUG - #define DEBUG_MYSQL_QUERIES 0 -#else - #define DEBUG_MYSQL_QUERIES 0 -#endif - -DBcore::DBcore() { - mysql_init(&mysql); - pHost = 0; - pPort = 0; - pUser = 0; - pPassword = 0; - pDatabase = 0; - pCompress = false; -pSSL = false; -pStatus = Closed; -} - -DBcore::~DBcore() { - pStatus = Closed; - mysql_close(&mysql); -#if MYSQL_VERSION_ID >= 50003 - mysql_library_end(); -#else - mysql_server_end(); -#endif - safe_delete_array(pHost); - safe_delete_array(pUser); - safe_delete_array(pPassword); - safe_delete_array(pDatabase); -} - - -bool DBcore::ReadDBINI(char* host, char* user, char* passwd, char* database, unsigned int* port, bool* compress, bool* items) { - char line[256], * key, * val; - bool on_database_section = false; - FILE* f; - - if ((f = fopen(DB_INI_FILE, "r")) == NULL) { - LogWrite(DATABASE__ERROR, 0, "DBCore", "Unable to open '%s' for reading", DB_INI_FILE); - return false; - } - - //read each line - while (fgets(line, sizeof(line), f) != NULL) { - - //remove any new line or carriage return - while ((key = strstr(line, "\n")) != NULL) - *key = '\0'; - while ((key = strstr(line, "\r")) != NULL) - *key = '\0'; - - //ignore blank lines and commented lines - if (strlen(line) == 0 || line[0] == '#') - continue; - - key = strtok(line, "="); - - if (key == NULL) - continue; - - //don't do anything until we find the [Database] section - if (!on_database_section && strncasecmp(key, "[Database]", 10) == 0) - on_database_section = true; - else { - val = strtok(NULL, "="); - - if (val == NULL) - { - if (strcasecmp(key, "password") == 0) { - strcpy(passwd, ""); - items[2] = true; - } - continue; - } - if (strcasecmp(key, "host") == 0) { - strcpy(host, val); - items[0] = true; - } - else if (strcasecmp(key, "user") == 0) { - strcpy(user, val); - items[1] = true; - } - else if (strcasecmp(key, "password") == 0) { - strcpy(passwd, val); - items[2] = true; - } - else if (strcasecmp(key, "database") == 0) { - strcpy(database, val); - items[3] = true; - } - else if (strcasecmp(key, "port") == 0 && port) { - *port = atoul(val); - items[4] = true; - } - else if (strcasecmp(key, "compression") == 0) { - if (strcasecmp(val, "on") == 0) { - if(compress) { - *compress = true; - items[5] = true; - LogWrite(DATABASE__INFO, 0, "DBCore", "DB Compression on."); - } - } - } - } - } - - fclose(f); - - if (!on_database_section) { - LogWrite(DATABASE__ERROR, 0, "DBCore", "[Database] section not found in '%s'", DB_INI_FILE); - return false; - } - - return true; -} - - -// Sends the MySQL server a keepalive -void DBcore::ping() { - if (!MDatabase.trylock()) { - // well, if's it's locked, someone's using it. If someone's using it, it doesnt need a keepalive - return; - } - mysql_ping(&mysql); - - int32* errnum = new int32; - *errnum = mysql_errno(&mysql); - - switch (*errnum) - { - case CR_COMMANDS_OUT_OF_SYNC: - case CR_SERVER_GONE_ERROR: - case CR_UNKNOWN_ERROR: - { - LogWrite(DATABASE__ERROR, 0, "DBCore", "[Database] We lost connection to the database., errno: %i", errno); - break; - } - } - - safe_delete(errnum); - MDatabase.unlock(); -} - -bool DBcore::RunQuery(const char* query, int32 querylen, char* errbuf, MYSQL_RES** result, int32* affected_rows, int32* last_insert_id, int32* errnum, bool retry) { - if (errnum) - *errnum = 0; - if (errbuf) - errbuf[0] = 0; - bool ret = false; - LockMutex lock(&MDatabase); - if (pStatus != Connected) - Open(); - - LogWrite(DATABASE__QUERY, 0, "DBCore", query); - if (mysql_real_query(&mysql, query, querylen)) { - if (mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) - pStatus = Error; - if (mysql_errno(&mysql) == CR_SERVER_LOST || mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) { - if (retry) { - LogWrite(DATABASE__ERROR, 0, "DBCore", "Lost connection, attempting to recover..."); - ret = RunQuery(query, querylen, errbuf, result, affected_rows, last_insert_id, errnum, false); - } - else { - pStatus = Error; - if (errnum) - *errnum = mysql_errno(&mysql); - if (errbuf) - snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql)); - LogWrite(DATABASE__ERROR, 0, "DBCore", "#%i: %s\nQuery:\n%s", mysql_errno(&mysql), mysql_error(&mysql), query); - ret = false; - } - } - else { - if (errnum) - *errnum = mysql_errno(&mysql); - if (errbuf) - snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql)); - LogWrite(DATABASE__ERROR, 0, "DBCore", "#%i: %s\nQuery:\n%s", mysql_errno(&mysql), mysql_error(&mysql), query); - ret = false; - } - } - else { - if (result && mysql_field_count(&mysql)) { - *result = mysql_store_result(&mysql); - } - else if (result) - *result = 0; - if (affected_rows) - *affected_rows = mysql_affected_rows(&mysql); - if (last_insert_id) - *last_insert_id = mysql_insert_id(&mysql); - if (result) { - if (*result) { - ret = true; - } - else { - if (errnum) - *errnum = UINT_MAX; - if (errbuf){ - if((!affected_rows || (affected_rows && *affected_rows == 0)) && (!last_insert_id || (last_insert_id && *last_insert_id == 0))) - LogWrite(DATABASE__RESULT, 1, "DBCore", "No Result."); - } - ret = false; - } - } - else { - ret = true; - } - } - - if (ret) - { - char tmp1[200] = {0}; - char tmp2[200] = {0}; - if (result && (*result)) - snprintf(tmp1, sizeof(tmp1), ", %i rows returned", (int) mysql_num_rows(*result)); - if (affected_rows) - snprintf(tmp2, sizeof(tmp2), ", %i rows affected", (*affected_rows)); - - LogWrite(DATABASE__DEBUG, 0, "DBCore", "Query Successful%s%s", tmp1, tmp2); - } - else - LogWrite(DATABASE__DEBUG, 0, "DBCore", "Query returned no results in %s!\n%s", __FUNCTION__, query); - - return ret; -} - -int32 DBcore::DoEscapeString(char* tobuf, const char* frombuf, int32 fromlen) { - LockMutex lock(&MDatabase); - return mysql_real_escape_string(&mysql, tobuf, frombuf, fromlen); -} - -bool DBcore::Open(const char* iHost, const char* iUser, const char* iPassword, const char* iDatabase,int32 iPort, int32* errnum, char* errbuf, bool iCompress, bool iSSL) { - LockMutex lock(&MDatabase); - safe_delete_array(pHost); - safe_delete_array(pUser); - safe_delete_array(pPassword); - safe_delete_array(pDatabase); - pHost = new char[strlen(iHost) + 1]; - strcpy(pHost, iHost); - pUser = new char[strlen(iUser) + 1]; - strcpy(pUser, iUser); - pPassword = new char[strlen(iPassword) + 1]; - strcpy(pPassword, iPassword); - pDatabase = new char[strlen(iDatabase) + 1]; - strcpy(pDatabase, iDatabase); - pCompress = iCompress; - pPort = iPort; - pSSL = iSSL; - return Open(errnum, errbuf); -} - -bool DBcore::Open(int32* errnum, char* errbuf) { - if (errbuf) - errbuf[0] = 0; - LockMutex lock(&MDatabase); - if (GetStatus() == Connected) - return true; - if (GetStatus() == Error) - mysql_close(&mysql); - if (!pHost) - return false; - /* - Quagmire - added CLIENT_FOUND_ROWS flag to the connect - otherwise DB update calls would say 0 rows affected when the value already equalled - what the function was tring to set it to, therefore the function would think it failed - */ - int32 flags = CLIENT_FOUND_ROWS; - if (pCompress) - flags |= CLIENT_COMPRESS; - if (pSSL) - flags |= CLIENT_SSL; - if (mysql_real_connect(&mysql, pHost, pUser, pPassword, pDatabase, pPort, 0, flags)) { - pStatus = Connected; - return true; - } - else { - if (errnum) - *errnum = mysql_errno(&mysql); - if (errbuf) - snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql)); - pStatus = Error; - return false; - } -} - -char* DBcore::getEscapeString(const char* from_string){ - if(!from_string) - from_string =""; - int orig_size = strlen(from_string); - int escape_size = (orig_size * 2) + 1; - char* escaped = new char[escape_size]; - memset(escaped, 0, escape_size); - DoEscapeString(escaped, from_string, orig_size); - return escaped; -} - -string DBcore::getSafeEscapeString(const char* from_string){ - if(!from_string) - from_string =""; - int orig_size = strlen(from_string); - int escape_size = (orig_size * 2) + 1; - char* escaped = new char[escape_size]; - memset(escaped, 0, escape_size); - DoEscapeString(escaped, from_string, orig_size); - string ret = string(escaped); - safe_delete_array(escaped); - return ret; -} - -string DBcore::getSafeEscapeString(string* from_string){ - if(!from_string) - return ""; - int orig_size = from_string->length(); - int escape_size = (orig_size * 2) + 1; - char* escaped = new char[escape_size]; - memset(escaped, 0, escape_size); - DoEscapeString(escaped, from_string->c_str(), orig_size); - string ret = string(escaped); - safe_delete_array(escaped); - return ret; -} - diff --git a/source/common/dbcore.h b/source/common/dbcore.h deleted file mode 100644 index b6cbfd2..0000000 --- a/source/common/dbcore.h +++ /dev/null @@ -1,80 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef DBCORE_H -#define DBCORE_H - -#ifdef WIN32 - #include - #include - //#include -#endif -#include -#include "../common/types.h" -#include "../common/Mutex.h" -#include "../common/linked_list.h" -#include "../common/queue.h" -#include "../common/timer.h" -#include "../common/Condition.h" -#ifdef LOGIN - #define DB_INI_FILE "login_db.ini" -#endif -#ifdef WORLD - #define DB_INI_FILE "world_db.ini" -#endif -#ifdef PARSER - #define DB_INI_FILE "parser_db.ini" -#endif -#ifdef PATCHER - #define DB_INI_FILE "patcher_db.ini" -#endif -class DBcore{ -public: - enum eStatus { Closed, Connected, Error }; - DBcore(); - ~DBcore(); - eStatus GetStatus() { return pStatus; } - bool RunQuery(const char* query, int32 querylen, char* errbuf = 0, MYSQL_RES** result = 0, int32* affected_rows = 0, int32* last_insert_id = 0, int32* errnum = 0, bool retry = true); - int32 DoEscapeString(char* tobuf, const char* frombuf, int32 fromlen); - void ping(); - char* getEscapeString(const char* from_string); - string getSafeEscapeString(const char* from_string); - string getSafeEscapeString(string* from_string); - -protected: - bool Open(const char* iHost, const char* iUser, const char* iPassword, const char* iDatabase, int32 iPort, int32* errnum = 0, char* errbuf = 0, bool iCompress = false, bool iSSL = false); - bool ReadDBINI(char *host, char *user, char *pass, char *db, unsigned int* port, bool* compress, bool *items); -private: - bool Open(int32* errnum = 0, char* errbuf = 0); - - MYSQL mysql; - Mutex MDatabase; - eStatus pStatus; - - char* pHost; - char* pUser; - char* pPassword; - char* pDatabase; - bool pCompress; - int32 pPort; - bool pSSL; -}; -#endif - - diff --git a/source/common/debug.cpp b/source/common/debug.cpp deleted file mode 100644 index 3f2f98b..0000000 --- a/source/common/debug.cpp +++ /dev/null @@ -1,336 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ - -/* - JA: File rendered obsolete (2011-08-12) - -#include "debug.h" - -#include -using namespace std; -#include -#include -#ifdef WIN32 - #include - - #define snprintf _snprintf - #define vsnprintf _vsnprintf - #define strncasecmp _strnicmp - #define strcasecmp _stricmp -#else - #include - #include - #include -#endif -#include "../common/MiscFunctions.h" - -EQEMuLog* LogFile = new EQEMuLog; -AutoDelete adlf(&LogFile); - -static const char* FileNames[EQEMuLog::MaxLogID] = { "logs/eq2emu", "logs/eq2emu", "logs/eq2emu_error", "logs/eq2emu_debug", "logs/eq2emu_quest", "logs/eq2emu_commands" }; -static const char* LogNames[EQEMuLog::MaxLogID] = { "Status", "Normal", "Error", "Debug", "Quest", "Command" }; - -EQEMuLog::EQEMuLog() { - for (int i=0; i= 2 - pLogStatus[i] = 1 | 2; -#else - pLogStatus[i] = 0; -#endif - logCallbackFmt[i] = NULL; - logCallbackBuf[i] = NULL; - } -#if EQDEBUG < 2 - pLogStatus[Status] = 3; - pLogStatus[Error] = 3; - pLogStatus[Debug] = 3; - pLogStatus[Quest] = 2; - pLogStatus[Commands] = 2; -#endif -} - -EQEMuLog::~EQEMuLog() { - for (int i=0; i= MaxLogID) { - return false; - } - LockMutex lock(&MOpen); - if (pLogStatus[id] & 4) { - return false; - } - if (fp[id]) { - return true; - } - - char exename[200] = ""; -#if defined(WORLD) - snprintf(exename, sizeof(exename), "_world"); -#elif defined(ZONE) - snprintf(exename, sizeof(exename), "_zone"); -#endif - char filename[200]; -#ifndef NO_PIDLOG - snprintf(filename, sizeof(filename), "%s%s_%04i.log", FileNames[id], exename, getpid()); -#else - snprintf(filename, sizeof(filename), "%s%s.log", FileNames[id], exename); -#endif - fp[id] = fopen(filename, "a"); - if (!fp[id]) { - cerr << "Failed to open log file: " << filename << endl; - pLogStatus[id] |= 4; // set file state to error - return false; - } - fputs("---------------------------------------------\n",fp[id]); - return true; -} - -bool EQEMuLog::write(LogIDs id, const char *fmt, ...) { - char buffer[4096]; - - if (!this) { - return false; - } - if (id >= MaxLogID) { - return false; - } - bool dofile = false; - if (pLogStatus[id] & 1) { - dofile = open(id); - } - if (!(dofile || pLogStatus[id] & 2)) - return false; - LockMutex lock(&MLog[id]); - - time_t aclock; - struct tm *newtime; - - time( &aclock ); //Get time in seconds - newtime = localtime( &aclock ); //Convert time to struct - - if (dofile){ -#ifndef NO_PIDLOG - fprintf(fp[id], "[%04d%02d%02d %02d:%02d:%02d] ", newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec); -#else - fprintf(fp[id], "%04i [%04d%02d%02d %02d:%02d:%02d] ", getpid(), newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec); -#endif - } - - va_list argptr; - va_start(argptr, fmt); - vsnprintf(buffer, sizeof(buffer), fmt, argptr); - va_end(argptr); - if (dofile) - fprintf(fp[id], "%s\n", buffer); - if(logCallbackFmt[id]) { - msgCallbackFmt p = logCallbackFmt[id]; - p(id, fmt, argptr ); - } - - if (pLogStatus[id] & 2) { - if (pLogStatus[id] & 8) { - fprintf(stderr, "[%04d%02d%02d %02d:%02d:%02d] [%s] ", newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, LogNames[id]); - fprintf(stderr, "%s\n", buffer); - } - else { - fprintf(stdout, "[%04d%02d%02d %02d:%02d:%02d] [%s] ", newtime->tm_year+1900, newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, LogNames[id]); - fprintf(stdout, "%s\n", buffer); - } - } - if (dofile) - fprintf(fp[id], "\n"); - if (pLogStatus[id] & 2) { - if (pLogStatus[id] & 8) - fprintf(stderr, "\n"); - else - fprintf(stdout, "\n"); - } - if(dofile) - fflush(fp[id]); - return true; -} - -bool EQEMuLog::writebuf(LogIDs id, const char *buf, int8 size, int32 count) { - if (!this) { - return false; - } - if (id >= MaxLogID) { - return false; - } - bool dofile = false; - if (pLogStatus[id] & 1) { - dofile = open(id); - } - if (!(dofile || pLogStatus[id] & 2)) - return false; - LockMutex lock(&MLog[id]); - - time_t aclock; - struct tm *newtime; - - time( &aclock ); // Get time in seconds - newtime = localtime( &aclock ); // Convert time to struct - - if (dofile){ -#ifndef NO_PIDLOG - fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] ", newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec); -#else - fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] ", getpid(), newtime->tm_mon+1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec); -#endif - } - - if (dofile) { - fwrite(buf, size, count, fp[id]); - fprintf(fp[id], "\n"); - } - if(logCallbackBuf[id]) { - msgCallbackBuf p = logCallbackBuf[id]; - p(id, buf, size, count); - } - if (pLogStatus[id] & 2) { - if (pLogStatus[id] & 8) { - fprintf(stderr, "[%s] ", LogNames[id]); - fwrite(buf, size, count, stderr); - fprintf(stderr, "\n"); - } else { - fprintf(stdout, "[%s] ", LogNames[id]); - fwrite(buf, size, count, stdout); - fprintf(stdout, "\n"); - } - } - if(dofile) - fflush(fp[id]); - return true; -} - -bool EQEMuLog::writeNTS(LogIDs id, bool dofile, const char *fmt, ...) { - char buffer[4096]; - va_list argptr; - va_start(argptr, fmt); - vsnprintf(buffer, sizeof(buffer), fmt, argptr); - va_end(argptr); - if (dofile) - fprintf(fp[id], "%s\n", buffer); - if (pLogStatus[id] & 2) { - if (pLogStatus[id] & 8) - fprintf(stderr, "%s\n", buffer); - else - fprintf(stdout, "%s\n", buffer); - } - return true; -}; - -bool EQEMuLog::Dump(LogIDs id, int8* data, int32 size, int32 cols, int32 skip) { - if (!this) { -#if EQDEBUG >= 10 - cerr << "Error: Dump() from null pointer"<= MaxLogID) - return false; - bool dofile = false; - if (pLogStatus[id] & 1) { - dofile = open(id); - } - if (!(dofile || pLogStatus[id] & 2)) - return false; - LockMutex lock(&MLog[id]); - write(id, "Dumping Packet: %i", size); - // Output as HEX - int j = 0; char* ascii = new char[cols+1]; memset(ascii, 0, cols+1); - int32 i; - for(i=skip; i= 32 && data[i] < 127) - ascii[j++] = data[i]; - else - ascii[j++] = '.'; - } - int32 k = ((i-skip)-1)%cols; - if (k < 8) - writeNTS(id, dofile, " "); - for (int32 h = k+1; h < cols; h++) { - writeNTS(id, dofile, " "); - } - writeNTS(id, dofile, " | %s\n", ascii); - if (dofile) - fflush(fp[id]); - safe_delete_array(ascii); - return true; -} - -void EQEMuLog::SetCallback(LogIDs id, msgCallbackFmt proc) { - if (!this) - return; - if (id >= MaxLogID) { - return; - } - logCallbackFmt[id] = proc; -} - -void EQEMuLog::SetCallback(LogIDs id, msgCallbackBuf proc) { - if (!this) - return; - if (id >= MaxLogID) { - return; - } - logCallbackBuf[id] = proc; -} - -void EQEMuLog::SetAllCallbacks(msgCallbackFmt proc) { - if (!this) - return; - int r; - for(r = Status; r < MaxLogID; r++) { - SetCallback((LogIDs)r, proc); - } -} - -void EQEMuLog::SetAllCallbacks(msgCallbackBuf proc) { - if (!this) - return; - int r; - for(r = Status; r < MaxLogID; r++) { - SetCallback((LogIDs)r, proc); - } -} -*/ \ No newline at end of file diff --git a/source/common/debug.h b/source/common/debug.h deleted file mode 100644 index 7422d5e..0000000 --- a/source/common/debug.h +++ /dev/null @@ -1,143 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef EQDEBUG_H -#define EQDEBUG_H - -// Debug Levels -/* - 1 = Normal - 3 = Some extended debug info - 5 = Light DETAIL info - 7 = Heavy DETAIL info - 9 = DumpPacket/PrintPacket - You should use even numbers too, to define any subset of the above basic template -*/ -#ifndef EQDEBUG - #define EQDEBUG 1 -#endif - - -#if defined(DEBUG) && defined(WIN32) - //#ifndef _CRTDBG_MAP_ALLOC - #include - #include - #if (_MSC_VER < 1300) - #include - #include - #define _CRTDBG_MAP_ALLOC - #define new new(_NORMAL_BLOCK, __FILE__, __LINE__) - #define malloc(s) _malloc_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__) - #endif - //#endif -#endif - -#ifndef ThrowError - void CatchSignal(int); - #if defined(CATCH_CRASH) || defined(_EQDEBUG) - #define ThrowError(errstr) { cout << "Fatal error: " << errstr << " (" << __FILE__ << ", line " << __LINE__ << ")" << endl; LogWrite(WORLD__ERROR, 0, "Debug", "Thrown Error: %s (%s:%i)", errstr, __FILE__, __LINE__); throw errstr; } - #else - #define ThrowError(errstr) { cout << "Fatal error: " << errstr << " (" << __FILE__ << ", line " << __LINE__ << ")" << endl; LogWrite(WORLD__ERROR, 0, "Debug", "Thrown Error: %s (%s:%i)", errstr, __FILE__, __LINE__); CatchSignal(0); } - #endif -#endif - -#ifdef WIN32 - // VS6 doesn't like the length of STL generated names: disabling - #pragma warning(disable:4786) -#endif - -#ifndef WIN32 - #define DebugBreak() if(0) {} -#endif - -#ifdef WIN32 - #include - #include -#endif - -#include "../common/Mutex.h" -#include -#include - - -class EQEMuLog { -public: - EQEMuLog(); - ~EQEMuLog(); - - enum LogIDs { - Status = 0, //this must stay the first entry in this list - Normal, - Error, - Debug, - Quest, - Commands, - MaxLogID - }; - - //these are callbacks called for each - typedef void (* msgCallbackBuf)(LogIDs id, const char *buf, int8 size, int32 count); - typedef void (* msgCallbackFmt)(LogIDs id, const char *fmt, va_list ap); - - void SetAllCallbacks(msgCallbackFmt proc); - void SetAllCallbacks(msgCallbackBuf proc); - void SetCallback(LogIDs id, msgCallbackFmt proc); - void SetCallback(LogIDs id, msgCallbackBuf proc); - - bool writebuf(LogIDs id, const char *buf, int8 size, int32 count); - bool write(LogIDs id, const char *fmt, ...); - bool Dump(LogIDs id, int8* data, int32 size, int32 cols=16, int32 skip=0); -private: - bool open(LogIDs id); - bool writeNTS(LogIDs id, bool dofile, const char *fmt, ...); // no error checking, assumes is open, no locking, no timestamp, no newline - - Mutex MOpen; - Mutex MLog[MaxLogID]; - FILE* fp[MaxLogID]; -/* LogStatus: bitwise variable - 1 = output to file - 2 = output to stdout - 4 = fopen error, dont retry - 8 = use stderr instead (2 must be set) -*/ - int8 pLogStatus[MaxLogID]; - - msgCallbackFmt logCallbackFmt[MaxLogID]; - msgCallbackBuf logCallbackBuf[MaxLogID]; -}; - -//extern EQEMuLog* LogFile; - -#ifdef _EQDEBUG -class PerformanceMonitor { -public: - PerformanceMonitor(sint64* ip) { - p = ip; - QueryPerformanceCounter(&tmp); - } - ~PerformanceMonitor() { - LARGE_INTEGER tmp2; - QueryPerformanceCounter(&tmp2); - *p += tmp2.QuadPart - tmp.QuadPart; - } - LARGE_INTEGER tmp; - sint64* p; -}; -#endif -#endif diff --git a/source/common/linked_list.h b/source/common/linked_list.h deleted file mode 100644 index 023a9d2..0000000 --- a/source/common/linked_list.h +++ /dev/null @@ -1,445 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef LINKEDLIST_H -#define LINKEDLIST_H - -#include "types.h" - -enum direction{FORWARD,BACKWARD}; - -template class LinkedListIterator; - -template -class ListElement -{ -private: - - TYPE data; - ListElement* next; - ListElement* prev; -public: - ListElement (); - ListElement (const TYPE&); - ListElement (const ListElement&); - - ~ListElement (); - - ListElement& operator= (const ListElement&); - - ListElement* GetLast () - { - ListElement* tmp = this; - while (tmp->GetNext()) { - tmp = tmp->GetNext(); - } - return tmp; - } - ListElement* GetNext () const { return next ; } - ListElement* GetPrev () const { return prev ; } - - inline TYPE& GetData () { return data ; } - inline const TYPE& GetData () const { return data ; } - - void SetData ( const TYPE& d ) { data = d ; } // Quagmire - this may look like a mem leak, but dont change it, this behavior is expected where it's called - void SetLastNext ( ListElement* p ) - { - GetLast()->SetNext(p); - } - void SetNext (ListElement* n) { next = n ; } - void SetPrev (ListElement* p) { prev = p ; } - - void ReplaceData(const TYPE&); -}; - -template -class LinkedList -{ -private: - int32 count; - ListElement* first; - bool list_destructor_invoked; - -public: - - LinkedList(); - ~LinkedList(); - bool dont_delete; - LinkedList& operator= (const LinkedList&); - - void Append (const TYPE&); - void Insert (const TYPE&); - TYPE Pop(); - TYPE PeekTop(); - void Clear(); - void LCount() { count--; } - void ResetCount() { count=0; } - int32 Count() { return count; } - friend class LinkedListIterator; -}; - -template -class LinkedListIterator -{ -private: - LinkedList& list; - ListElement* current_element; - direction dir; - -public: - LinkedListIterator(LinkedList& l,direction d = FORWARD) : list(l), dir(d) {}; - - void Advance(); - const TYPE& GetData(); - bool IsFirst() - { - if (current_element->GetPrev() == 0) - return true; - else - return false; - } - bool IsLast() - { - if (current_element->GetNext() == 0) - return true; - else - return false; - } - bool MoreElements(); - void MoveFirst(); - void MoveLast(); - void RemoveCurrent(bool DeleteData = true); - void Replace(const TYPE& new_data); - void Reset(); - void SetDir(direction); -}; - -template -void LinkedListIterator::Advance() -{ - if (current_element == 0) - { - return; - } - if (dir == FORWARD) - { - current_element = current_element->GetNext(); - } - else - { - current_element = current_element->GetPrev(); - } - - if (list.list_destructor_invoked) - { - while(current_element && current_element->GetData() == 0) - { -// if (current_element == 0) -// { -// return; -// } - if (dir == FORWARD) - { - current_element = current_element->GetNext(); - } - else - { - current_element = current_element->GetPrev(); - } - } - } -} - -template -bool LinkedListIterator::MoreElements() -{ - if (current_element == 0) - return false; - return true; -} - -template -const TYPE& LinkedListIterator::GetData() -{ - return current_element->GetData(); -} - -template -void LinkedListIterator::MoveFirst() -{ - ListElement* prev = current_element->GetPrev(); - ListElement* next = current_element->GetNext(); - - if (prev == 0) - { - return; - } - -// if (prev != 0) -// { - prev->SetNext(next); -// } - if (next != 0) - { - next->SetPrev(prev); - } - current_element->SetPrev(0); - current_element->SetNext(list.first); - list.first->SetPrev(current_element); - list.first = current_element; -} - - -template -void LinkedListIterator::MoveLast() -{ - ListElement* prev = current_element->GetPrev(); - ListElement* next = current_element->GetNext(); - - if (next == 0) - { - return; - } - - if (prev != 0) - { - prev->SetNext(next); - } - else - { - list.first = next; - } -// if (next != 0) -// { - next->SetPrev(prev); -// } - current_element->SetNext(0); - current_element->SetPrev(next->GetLast()); - next->GetLast()->SetNext(current_element); -} - -template -void LinkedListIterator::RemoveCurrent(bool DeleteData) -{ - ListElement* save; - - if (list.first == current_element) - { - list.first = current_element->GetNext(); - } - - if (current_element->GetPrev() != 0) - { - current_element->GetPrev()->SetNext(current_element->GetNext()); - } - if (current_element->GetNext() != 0) - { - current_element->GetNext()->SetPrev(current_element->GetPrev()); - } - if (dir == FORWARD) - { - save = current_element->GetNext(); - } - else - { - save = current_element->GetPrev(); - } - current_element->SetNext(0); - current_element->SetPrev(0); - if (!DeleteData) - current_element->SetData(0); - safe_delete(current_element); - current_element = save; - list.LCount(); -} - -template -void LinkedListIterator::Replace(const TYPE& new_data) -{ - current_element->ReplaceData(new_data); -} - -template -void LinkedListIterator::Reset() -{ - if (!(&list)) - { - current_element=0; - return; - } - - if (dir == FORWARD) - { - current_element = list.first; - } - else - { - if (list.first == 0) - { - current_element = 0; - } - else - { - current_element = list.first->GetLast(); - } - } - - if (list.list_destructor_invoked) - { - while(current_element && current_element->GetData() == 0) - { -// if (current_element == 0) -// { -// return; -// } - if (dir == FORWARD) - { - current_element = current_element->GetNext(); - } - else - { - current_element = current_element->GetPrev(); - } - } - } -} - -template -void LinkedListIterator::SetDir(direction d) -{ - dir = d; -} - -template -ListElement::ListElement(const TYPE& d) -{ - data = d; - next = 0; - prev = 0; -} - -template -ListElement::~ListElement() -{ -// cout << "ListElement::~ListElement()" << endl; - - if (data != 0) - safe_delete(data); - data = 0; - if (next != 0) - { - safe_delete(next); - next = 0; - } -} - -template -void ListElement::ReplaceData(const TYPE& new_data) -{ - if (data != 0) - safe_delete(data); - data = new_data; -} - -template -LinkedList::LinkedList() -{ - list_destructor_invoked = false; - first = 0; - count = 0; - dont_delete = false; -} - -template -LinkedList::~LinkedList() -{ - list_destructor_invoked = true; - if(!dont_delete) - Clear(); -} - -template -void LinkedList::Clear() { - while (first) { - ListElement* tmp = first; - first = tmp->GetNext(); - tmp->SetNext(0); - safe_delete(tmp); - } - ResetCount(); -} - -template -void LinkedList::Append(const TYPE& data) -{ - ListElement* new_element = new ListElement(data); - - if (first == 0) - { - first = new_element; - } - else - { - new_element->SetPrev(first->GetLast()); - first->SetLastNext(new_element); - } - count++; -} - -template -void LinkedList::Insert(const TYPE& data) -{ - ListElement* new_element = new ListElement(data); - - new_element->SetNext(first); - if (first != 0) - { - first->SetPrev(new_element); - } - first = new_element; - count++; -} - -template -TYPE LinkedList::Pop() { - TYPE ret = 0; - if (first) { - ListElement* tmpdel = first; - first = tmpdel->GetNext(); - if (first) - first->SetPrev(0); - ret = tmpdel->GetData(); - tmpdel->SetData(0); - tmpdel->SetNext(0); - safe_delete(tmpdel); - count--; - } - return ret; -} - -template -TYPE LinkedList::PeekTop() { - if (first) - return first->GetData(); - return 0; -} - -#endif - - diff --git a/source/common/md5.cpp b/source/common/md5.cpp deleted file mode 100644 index 1244c8c..0000000 --- a/source/common/md5.cpp +++ /dev/null @@ -1,281 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include /* for memcpy() */ -#include "../common/md5.h" -#include "../common/MiscFunctions.h" -#include "../common/seperator.h" - -MD5::MD5() { - memset(pMD5, 0, 16); -} - -MD5::MD5(const uchar* buf, uint32 len) { - Generate(buf, len, pMD5); -} - -MD5::MD5(const char* buf, uint32 len) { - Generate((const uchar*) buf, len, pMD5); -} - -MD5::MD5(const int8 buf[16]) { - Set(buf); -} - -MD5::MD5(const char* iMD5String) { - Set(iMD5String); -} - -void MD5::Generate(const char* iString) { - Generate((const uchar*) iString, strlen(iString)); -} - -void MD5::Generate(const int8* buf, uint32 len) { - Generate(buf, len, pMD5); -} - -bool MD5::Set(const int8 buf[16]) { - memcpy(pMD5, buf, 16); - return true; -} - -bool MD5::Set(const char* iMD5String) { - char tmp[5] = { '0', 'x', 0, 0, 0 }; - for (int i=0; i<16; i++) { - tmp[2] = iMD5String[i*2]; - tmp[3] = iMD5String[(i*2) + 1]; - if (!Seperator::IsHexNumber(tmp)) - return false; - pMD5[i] = hextoi(tmp); - } - return true; -} - -MD5::operator const char* () { - snprintf(pMD5String, sizeof(pMD5String), "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", pMD5[0], pMD5[1], pMD5[2], pMD5[3], pMD5[4], pMD5[5], pMD5[6], pMD5[7], pMD5[8], pMD5[9], pMD5[10], pMD5[11], pMD5[12], pMD5[13], pMD5[14], pMD5[15]); - return pMD5String; -} - -bool MD5::operator== (const MD5& iMD5) { - if (memcmp(pMD5, iMD5.pMD5, 16) == 0) - return true; - else - return false; -} - -bool MD5::operator== (const int8* iMD5) { - if (memcmp(pMD5, iMD5, 16) == 0) - return true; - else - return false; -} - -bool MD5::operator== (const char* iMD5String) { - char tmp[5] = { '0', 'x', 0, 0, 0 }; - for (int i=0; i<16; i++) { - tmp[2] = iMD5String[i*2]; - tmp[3] = iMD5String[(i*2) + 1]; - if (pMD5[i] != hextoi(tmp)) - return false; - } - return true; -} - -MD5& MD5::operator= (const MD5& iMD5) { - memcpy(pMD5, iMD5.pMD5, 16); - return *this; -} - -MD5* MD5::operator= (const MD5* iMD5) { - memcpy(pMD5, iMD5->pMD5, 16); - return this; -} - -/* Byte-swap an array of words to little-endian. (Byte-sex independent) */ -void MD5::byteSwap(uint32 *buf, uint32 words) { - int8 *p = (int8 *)buf; - do { - *buf++ = (uint32)((uint32)p[3]<<8 | p[2]) << 16 | - ((uint32)p[1]<<8 | p[0]); - p += 4; - } while (--words); -} - -void MD5::Generate(const int8* buf, uint32 len, int8 digest[16]) { - MD5Context ctx; - Init(&ctx); - Update(&ctx, buf, len); - Final(digest, &ctx); -} - -/* Start MD5 accumulation. */ -void MD5::Init(struct MD5Context *ctx) { - ctx->hash[0] = 0x67452301; - ctx->hash[1] = 0xefcdab89; - ctx->hash[2] = 0x98badcfe; - ctx->hash[3] = 0x10325476; - ctx->bytes[1] = ctx->bytes[0] = 0; -} - -/* Update ctx to reflect the addition of another buffer full of bytes. */ -void MD5::Update(struct MD5Context *ctx, int8 const *buf, uint32 len) { - uint32 t = ctx->bytes[0]; - if ((ctx->bytes[0] = t + len) < t) /* Update 64-bit byte count */ - ctx->bytes[1]++; /* Carry from low to high */ - - - - t = 64 - (t & 0x3f); /* Bytes available in ctx->input (>= 1) */ - if (t > len) { - memcpy((int8*)ctx->input+64-t, buf, len); - return; - } - /* First chunk is an odd size */ - memcpy((int8*)ctx->input+64-t, buf, t); - byteSwap(ctx->input, 16); - Transform(ctx->hash, ctx->input); - buf += t; - len -= t; - /* Process data in 64-byte chunks */ - while (len >= 64) { - memcpy(ctx->input, buf, 64); - byteSwap(ctx->input, 16); - Transform(ctx->hash, ctx->input); - buf += 64; - len -= 64; - } - /* Buffer any remaining bytes of data */ - memcpy(ctx->input, buf, len); -} - -/* Final wrapup - pad to 64-byte boundary with the bit pattern -* 1 0* (64-bit count of bits processed, LSB-first) */ -void MD5::Final(int8 digest[16], MD5Context *ctx) { - int count = ctx->bytes[0] & 0x3F; /* Bytes mod 64 */ - int8 *p = (int8*)ctx->input + count; - /* Set the first byte of padding to 0x80. There is always room. */ - *p++ = 0x80; - /* Bytes of zero padding needed to make 56 bytes (-8..55) */ - count = 56 - 1 - count; - if (count < 0) { /* Padding forces an extra block */ - memset(p, 0, count+8); - byteSwap(ctx->input, 16); - Transform(ctx->hash, ctx->input); - p = (int8*)ctx->input; - count = 56; - } - memset(p, 0, count); - byteSwap(ctx->input, 14); - /* Append 8 bytes of length in *bits* and transform */ - ctx->input[14] = ctx->bytes[0] << 3; - - ctx->input[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29; - Transform(ctx->hash, ctx->input); - byteSwap(ctx->hash, 4); - memcpy(digest, ctx->hash, 16); - memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */ -} - -/* The four core functions */ -#define F1(x, y, z) (z ^ (x & (y ^ z))) -#define F2(x, y, z) F1(z, x, y) -#define F3(x, y, z) (x ^ y ^ z) -#define F4(x, y, z) (y ^ (x | ~z)) -/* This is the central step in the MD5 algorithm. */ -#define MD5STEP(f,w,x,y,z,in,s) (w += f(x,y,z)+in, w = (w<>(32-s)) + x) - - - -/* The heart of the MD5 algorithm. */ -void MD5::Transform(uint32 hash[4], const uint32 input[16]) { - uint32 a = hash[0], b = hash[1], c = hash[2], d = hash[3]; - - MD5STEP(F1, a, b, c, d, input[ 0]+0xd76aa478, 7); - MD5STEP(F1, d, a, b, c, input[ 1]+0xe8c7b756, 12); - MD5STEP(F1, c, d, a, b, input[ 2]+0x242070db, 17); - MD5STEP(F1, b, c, d, a, input[ 3]+0xc1bdceee, 22); - MD5STEP(F1, a, b, c, d, input[ 4]+0xf57c0faf, 7); - MD5STEP(F1, d, a, b, c, input[ 5]+0x4787c62a, 12); - MD5STEP(F1, c, d, a, b, input[ 6]+0xa8304613, 17); - MD5STEP(F1, b, c, d, a, input[ 7]+0xfd469501, 22); - MD5STEP(F1, a, b, c, d, input[ 8]+0x698098d8, 7); - MD5STEP(F1, d, a, b, c, input[ 9]+0x8b44f7af, 12); - MD5STEP(F1, c, d, a, b, input[10]+0xffff5bb1, 17); - MD5STEP(F1, b, c, d, a, input[11]+0x895cd7be, 22); - MD5STEP(F1, a, b, c, d, input[12]+0x6b901122, 7); - MD5STEP(F1, d, a, b, c, input[13]+0xfd987193, 12); - MD5STEP(F1, c, d, a, b, input[14]+0xa679438e, 17); - MD5STEP(F1, b, c, d, a, input[15]+0x49b40821, 22); - - MD5STEP(F2, a, b, c, d, input[ 1]+0xf61e2562, 5); - MD5STEP(F2, d, a, b, c, input[ 6]+0xc040b340, 9); - MD5STEP(F2, c, d, a, b, input[11]+0x265e5a51, 14); - MD5STEP(F2, b, c, d, a, input[ 0]+0xe9b6c7aa, 20); - MD5STEP(F2, a, b, c, d, input[ 5]+0xd62f105d, 5); - MD5STEP(F2, d, a, b, c, input[10]+0x02441453, 9); - MD5STEP(F2, c, d, a, b, input[15]+0xd8a1e681, 14); - MD5STEP(F2, b, c, d, a, input[ 4]+0xe7d3fbc8, 20); - MD5STEP(F2, a, b, c, d, input[ 9]+0x21e1cde6, 5); - MD5STEP(F2, d, a, b, c, input[14]+0xc33707d6, 9); - MD5STEP(F2, c, d, a, b, input[ 3]+0xf4d50d87, 14); - MD5STEP(F2, b, c, d, a, input[ 8]+0x455a14ed, 20); - MD5STEP(F2, a, b, c, d, input[13]+0xa9e3e905, 5); - MD5STEP(F2, d, a, b, c, input[ 2]+0xfcefa3f8, 9); - MD5STEP(F2, c, d, a, b, input[ 7]+0x676f02d9, 14); - MD5STEP(F2, b, c, d, a, input[12]+0x8d2a4c8a, 20); - - - - - MD5STEP(F3, a, b, c, d, input[ 5]+0xfffa3942, 4); - MD5STEP(F3, d, a, b, c, input[ 8]+0x8771f681, 11); - MD5STEP(F3, c, d, a, b, input[11]+0x6d9d6122, 16); - MD5STEP(F3, b, c, d, a, input[14]+0xfde5380c, 23); - MD5STEP(F3, a, b, c, d, input[ 1]+0xa4beea44, 4); - MD5STEP(F3, d, a, b, c, input[ 4]+0x4bdecfa9, 11); - MD5STEP(F3, c, d, a, b, input[ 7]+0xf6bb4b60, 16); - MD5STEP(F3, b, c, d, a, input[10]+0xbebfbc70, 23); - MD5STEP(F3, a, b, c, d, input[13]+0x289b7ec6, 4); - MD5STEP(F3, d, a, b, c, input[ 0]+0xeaa127fa, 11); - MD5STEP(F3, c, d, a, b, input[ 3]+0xd4ef3085, 16); - MD5STEP(F3, b, c, d, a, input[ 6]+0x04881d05, 23); - MD5STEP(F3, a, b, c, d, input[ 9]+0xd9d4d039, 4); - MD5STEP(F3, d, a, b, c, input[12]+0xe6db99e5, 11); - MD5STEP(F3, c, d, a, b, input[15]+0x1fa27cf8, 16); - MD5STEP(F3, b, c, d, a, input[ 2]+0xc4ac5665, 23); - - MD5STEP(F4, a, b, c, d, input[ 0]+0xf4292244, 6); - MD5STEP(F4, d, a, b, c, input[ 7]+0x432aff97, 10); - MD5STEP(F4, c, d, a, b, input[14]+0xab9423a7, 15); - MD5STEP(F4, b, c, d, a, input[ 5]+0xfc93a039, 21); - MD5STEP(F4, a, b, c, d, input[12]+0x655b59c3, 6); - MD5STEP(F4, d, a, b, c, input[ 3]+0x8f0ccc92, 10); - MD5STEP(F4, c, d, a, b, input[10]+0xffeff47d, 15); - MD5STEP(F4, b, c, d, a, input[ 1]+0x85845dd1, 21); - MD5STEP(F4, a, b, c, d, input[ 8]+0x6fa87e4f, 6); - MD5STEP(F4, d, a, b, c, input[15]+0xfe2ce6e0, 10); - MD5STEP(F4, c, d, a, b, input[ 6]+0xa3014314, 15); - MD5STEP(F4, b, c, d, a, input[13]+0x4e0811a1, 21); - MD5STEP(F4, a, b, c, d, input[ 4]+0xf7537e82, 6); - MD5STEP(F4, d, a, b, c, input[11]+0xbd3af235, 10); - MD5STEP(F4, c, d, a, b, input[ 2]+0x2ad7d2bb, 15); - MD5STEP(F4, b, c, d, a, input[ 9]+0xeb86d391, 21); - - hash[0] += a; hash[1] += b; hash[2] += c; hash[3] += d; -} diff --git a/source/common/md5.h b/source/common/md5.h deleted file mode 100644 index 6c54f94..0000000 --- a/source/common/md5.h +++ /dev/null @@ -1,64 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef MD5_H -#define MD5_H -#include "../common/types.h" - - -class MD5 { -public: - struct MD5Context { - uint32 hash[4]; - uint32 bytes[2]; - uint32 input[16]; - }; - static void Generate(const int8* buf, uint32 len, int8 digest[16]); - - static void Init(struct MD5Context *context); - static void Update(struct MD5Context *context, const int8 *buf, uint32 len); - static void Final(int8 digest[16], struct MD5Context *context); - - MD5(); - MD5(const uchar* buf, uint32 len); - MD5(const char* buf, uint32 len); - MD5(const int8 buf[16]); - MD5(const char* iMD5String); - - void Generate(const char* iString); - void Generate(const int8* buf, uint32 len); - bool Set(const int8 buf[16]); - bool Set(const char* iMD5String); - - bool operator== (const MD5& iMD5); - bool operator== (const int8 iMD5[16]); - bool operator== (const char* iMD5String); - - MD5& operator= (const MD5& iMD5); - MD5* operator= (const MD5* iMD5); - MD5* operator= (const int8* iMD5); - operator const char* (); -protected: - int8 pMD5[16]; -private: - static void byteSwap(uint32 *buf, uint32 words); - static void Transform(uint32 hash[4], const int32 input[16]); - char pMD5String[33]; -}; -#endif diff --git a/source/common/queue.h b/source/common/queue.h deleted file mode 100644 index e29ea05..0000000 --- a/source/common/queue.h +++ /dev/null @@ -1,128 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef QUEUE_H -#define QUEUE_H - -template -class MyQueue; - -template -class MyQueueNode -{ -public: - MyQueueNode(T* data) - { - next = 0; - this->data = data; - } - - friend class MyQueue; - -private: - T* data; - MyQueueNode* next; -}; - -template -class MyQueue -{ -public: - MyQueue() - { - head = tail = 0; - } - ~MyQueue() { - clear(); - } - - void push(T* data) - { - if (head == 0) - { - tail = head = new MyQueueNode(data); - } - else - { - tail->next = new MyQueueNode(data); - tail = tail->next; - } - } - - T* pop() - { - if (head == 0) - { - return 0; - } - - T* data = head->data; - MyQueueNode* next_node = head->next; - delete head; - head = next_node; - - return data; - } - - T* top() - { - if (head == 0) - { - return 0; - } - - return head->data; - } - - bool empty() - { - if (head == 0) - { - return true; - } - - return false; - } - - void clear() - { - T* d = 0; - while((d = pop())) { - delete d; - } - return; - } - - int count() - { - int count = 0; - MyQueueNode* d = head; - while(d != 0) { - count++; - d = d->next; - } - return(count); - } - -private: - MyQueueNode* head; - MyQueueNode* tail; -}; - -#endif diff --git a/source/common/sha512.cpp b/source/common/sha512.cpp deleted file mode 100644 index 10b9592..0000000 --- a/source/common/sha512.cpp +++ /dev/null @@ -1,155 +0,0 @@ -#include -#include -#include "sha512.h" - -const unsigned long long SHA512::sha512_k[80] = //ULL = uint64 - {0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, - 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL, - 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, - 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, - 0xd807aa98a3030242ULL, 0x12835b0145706fbeULL, - 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL, - 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, - 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL, - 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL, - 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, - 0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL, - 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL, - 0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, - 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL, - 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL, - 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL, - 0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL, - 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL, - 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, - 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL, - 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL, - 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, - 0xd192e819d6ef5218ULL, 0xd69906245565a910ULL, - 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL, - 0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, - 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL, - 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL, - 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL, - 0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL, - 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL, - 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, - 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL, - 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL, - 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, - 0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL, - 0x113f9804bef90daeULL, 0x1b710b35131c471bULL, - 0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, - 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL, - 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL, - 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL}; - -void SHA512::transform(const unsigned char *message, unsigned int block_nb) -{ - uint64 w[80]; - uint64 wv[8]; - uint64 t1, t2; - const unsigned char *sub_block; - int i, j; - for (i = 0; i < (int) block_nb; i++) { - sub_block = message + (i << 7); - for (j = 0; j < 16; j++) { - SHA2_PACK64(&sub_block[j << 3], &w[j]); - } - for (j = 16; j < 80; j++) { - w[j] = SHA512_F4(w[j - 2]) + w[j - 7] + SHA512_F3(w[j - 15]) + w[j - 16]; - } - for (j = 0; j < 8; j++) { - wv[j] = m_h[j]; - } - for (j = 0; j < 80; j++) { - t1 = wv[7] + SHA512_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6]) - + sha512_k[j] + w[j]; - t2 = SHA512_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]); - wv[7] = wv[6]; - wv[6] = wv[5]; - wv[5] = wv[4]; - wv[4] = wv[3] + t1; - wv[3] = wv[2]; - wv[2] = wv[1]; - wv[1] = wv[0]; - wv[0] = t1 + t2; - } - for (j = 0; j < 8; j++) { - m_h[j] += wv[j]; - } - - } -} - -void SHA512::init() -{ - m_h[0] = 0x6a09e667f3bcc908ULL; - m_h[1] = 0xbb67ae8584caa73bULL; - m_h[2] = 0x3c6ef372fe94f82bULL; - m_h[3] = 0xa54ff53a5f1d36f1ULL; - m_h[4] = 0x510e527fade682d1ULL; - m_h[5] = 0x9b05688c2b3e6c1fULL; - m_h[6] = 0x1f83d9abfb41bd6bULL; - m_h[7] = 0x5be0cd19137e2179ULL; - m_len = 0; - m_tot_len = 0; -} - -void SHA512::update(const unsigned char *message, unsigned int len) -{ - unsigned int block_nb; - unsigned int new_len, rem_len, tmp_len; - const unsigned char *shifted_message; - tmp_len = SHA384_512_BLOCK_SIZE - m_len; - rem_len = len < tmp_len ? len : tmp_len; - memcpy(&m_block[m_len], message, rem_len); - if (m_len + len < SHA384_512_BLOCK_SIZE) { - m_len += len; - return; - } - new_len = len - rem_len; - block_nb = new_len / SHA384_512_BLOCK_SIZE; - shifted_message = message + rem_len; - transform(m_block, 1); - transform(shifted_message, block_nb); - rem_len = new_len % SHA384_512_BLOCK_SIZE; - memcpy(m_block, &shifted_message[block_nb << 7], rem_len); - m_len = rem_len; - m_tot_len += (block_nb + 1) << 7; -} - -void SHA512::final(unsigned char *digest) -{ - unsigned int block_nb; - unsigned int pm_len; - unsigned int len_b; - int i; - block_nb = 1 + ((SHA384_512_BLOCK_SIZE - 17) - < (m_len % SHA384_512_BLOCK_SIZE)); - len_b = (m_tot_len + m_len) << 3; - pm_len = block_nb << 7; - memset(m_block + m_len, 0, pm_len - m_len); - m_block[m_len] = 0x80; - SHA2_UNPACK32(len_b, m_block + pm_len - 4); - transform(m_block, block_nb); - for (i = 0 ; i < 8; i++) { - SHA2_UNPACK64(m_h[i], &digest[i << 3]); - } -} - -std::string sha512(std::string input) -{ - unsigned char digest[SHA512::DIGEST_SIZE]; - memset(digest,0,SHA512::DIGEST_SIZE); - SHA512 ctx = SHA512(); - ctx.init(); - ctx.update((unsigned char*)input.c_str(), input.length()); - ctx.final(digest); - - char buf[2*SHA512::DIGEST_SIZE+1]; - buf[2*SHA512::DIGEST_SIZE] = 0; - for (int i = 0; i < SHA512::DIGEST_SIZE; i++) - sprintf(buf+i*2, "%02x", digest[i]); - return std::string(buf); -} \ No newline at end of file diff --git a/source/common/sha512.h b/source/common/sha512.h deleted file mode 100644 index 72ce5a8..0000000 --- a/source/common/sha512.h +++ /dev/null @@ -1,71 +0,0 @@ -#ifndef SHA512_H -#define SHA512_H -#include - -class SHA512 -{ -protected: - typedef unsigned char uint8; - typedef unsigned int uint32; - typedef unsigned long long uint64; - - const static uint64 sha512_k[]; - static const unsigned int SHA384_512_BLOCK_SIZE = (1024/8); - -public: - void init(); - void update(const unsigned char *message, unsigned int len); - void final(unsigned char *digest); - static const unsigned int DIGEST_SIZE = ( 512 / 8); - -protected: - void transform(const unsigned char *message, unsigned int block_nb); - unsigned int m_tot_len; - unsigned int m_len; - unsigned char m_block[2 * SHA384_512_BLOCK_SIZE]; - uint64 m_h[8]; -}; - - -std::string sha512(std::string input); - -#define SHA2_SHFR(x, n) (x >> n) -#define SHA2_ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n))) -#define SHA2_ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n))) -#define SHA2_CH(x, y, z) ((x & y) ^ (~x & z)) -#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z)) -#define SHA512_F1(x) (SHA2_ROTR(x, 28) ^ SHA2_ROTR(x, 34) ^ SHA2_ROTR(x, 39)) -#define SHA512_F2(x) (SHA2_ROTR(x, 14) ^ SHA2_ROTR(x, 18) ^ SHA2_ROTR(x, 41)) -#define SHA512_F3(x) (SHA2_ROTR(x, 1) ^ SHA2_ROTR(x, 8) ^ SHA2_SHFR(x, 7)) -#define SHA512_F4(x) (SHA2_ROTR(x, 19) ^ SHA2_ROTR(x, 61) ^ SHA2_SHFR(x, 6)) -#define SHA2_UNPACK32(x, str) \ -{ \ - *((str) + 3) = (uint8) ((x) ); \ - *((str) + 2) = (uint8) ((x) >> 8); \ - *((str) + 1) = (uint8) ((x) >> 16); \ - *((str) + 0) = (uint8) ((x) >> 24); \ -} -#define SHA2_UNPACK64(x, str) \ -{ \ - *((str) + 7) = (uint8) ((x) ); \ - *((str) + 6) = (uint8) ((x) >> 8); \ - *((str) + 5) = (uint8) ((x) >> 16); \ - *((str) + 4) = (uint8) ((x) >> 24); \ - *((str) + 3) = (uint8) ((x) >> 32); \ - *((str) + 2) = (uint8) ((x) >> 40); \ - *((str) + 1) = (uint8) ((x) >> 48); \ - *((str) + 0) = (uint8) ((x) >> 56); \ -} -#define SHA2_PACK64(str, x) \ -{ \ - *(x) = ((uint64) *((str) + 7) ) \ - | ((uint64) *((str) + 6) << 8) \ - | ((uint64) *((str) + 5) << 16) \ - | ((uint64) *((str) + 4) << 24) \ - | ((uint64) *((str) + 3) << 32) \ - | ((uint64) *((str) + 2) << 40) \ - | ((uint64) *((str) + 1) << 48) \ - | ((uint64) *((str) + 0) << 56); \ -} - -#endif \ No newline at end of file diff --git a/source/common/string_util.cpp b/source/common/string_util.cpp deleted file mode 100644 index df3790d..0000000 --- a/source/common/string_util.cpp +++ /dev/null @@ -1,529 +0,0 @@ -/* - * Copyright 2013 Facebook, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "string_util.h" -#include - -#ifdef _WINDOWS - #include - - #define snprintf _snprintf - #define strncasecmp _strnicmp - #define strcasecmp _stricmp - -#else - #include - #include -#include - -#endif - -#ifndef va_copy - #define va_copy(d,s) ((d) = (s)) -#endif - -// original source: -// https://github.com/facebook/folly/blob/master/folly/String.cpp -// -const std::string vStringFormat(const char* format, va_list args) -{ - std::string output; - va_list tmpargs; - - va_copy(tmpargs,args); - int characters_used = vsnprintf(nullptr, 0, format, tmpargs); - va_end(tmpargs); - - // Looks like we have a valid format string. - if (characters_used > 0) { - output.resize(characters_used + 1); - - va_copy(tmpargs,args); - characters_used = vsnprintf(&output[0], output.capacity(), format, tmpargs); - va_end(tmpargs); - - output.resize(characters_used); - - // We shouldn't have a format error by this point, but I can't imagine what error we - // could have by this point. Still, return empty string; - if (characters_used < 0) - output.clear(); - } - return output; -} - -const std::string str_tolower(std::string s) -{ - std::transform( - s.begin(), s.end(), s.begin(), - [](unsigned char c) { return ::tolower(c); } - ); - return s; -} - -std::vector split(std::string str_to_split, char delimiter) -{ - std::stringstream ss(str_to_split); - std::string item; - std::vector exploded_values; - while (std::getline(ss, item, delimiter)) { - exploded_values.push_back(item); - } - - return exploded_values; -} - -const std::string str_toupper(std::string s) -{ - std::transform( - s.begin(), s.end(), s.begin(), - [](unsigned char c) { return ::toupper(c); } - ); - return s; -} - -const std::string ucfirst(std::string s) -{ - std::string output = s; - if (!s.empty()) - output[0] = static_cast(::toupper(s[0])); - - return output; -} - -const std::string StringFormat(const char *format, ...) -{ - va_list args; - va_start(args, format); - std::string output = vStringFormat(format, args); - va_end(args); - return output; -} - -std::vector SplitString(const std::string &str, char delim) { - std::vector ret; - std::stringstream ss(str); - std::string item; - - while(std::getline(ss, item, delim)) { - ret.push_back(item); - } - - return ret; -} - -std::string implode(std::string glue, std::vector src) -{ - if (src.empty()) { - return {}; - } - - std::ostringstream output; - std::vector::iterator src_iter; - - for (src_iter = src.begin(); src_iter != src.end(); src_iter++) { - output << *src_iter << glue; - } - - std::string final_output = output.str(); - final_output.resize (output.str().size () - glue.size()); - - return final_output; -} - -std::string EscapeString(const std::string &s) { - std::string ret; - - size_t sz = s.length(); - for(size_t i = 0; i < sz; ++i) { - char c = s[i]; - switch(c) { - case '\x00': - ret += "\\x00"; - break; - case '\n': - ret += "\\n"; - break; - case '\r': - ret += "\\r"; - break; - case '\\': - ret += "\\\\"; - break; - case '\'': - ret += "\\'"; - break; - case '\"': - ret += "\\\""; - break; - case '\x1a': - ret += "\\x1a"; - break; - default: - ret.push_back(c); - break; - } - } - - return ret; -} - -std::string EscapeString(const char *src, size_t sz) { - std::string ret; - - for(size_t i = 0; i < sz; ++i) { - char c = src[i]; - switch(c) { - case '\x00': - ret += "\\x00"; - break; - case '\n': - ret += "\\n"; - break; - case '\r': - ret += "\\r"; - break; - case '\\': - ret += "\\\\"; - break; - case '\'': - ret += "\\'"; - break; - case '\"': - ret += "\\\""; - break; - case '\x1a': - ret += "\\x1a"; - break; - default: - ret.push_back(c); - break; - } - } - - return ret; -} - -bool StringIsNumber(const std::string &s) { - try { - auto r = stod(s); - return true; - } - catch (std::exception &) { - return false; - } -} - -void ToLowerString(std::string &s) { - std::transform(s.begin(), s.end(), s.begin(), ::tolower); -} - -void ToUpperString(std::string &s) { - std::transform(s.begin(), s.end(), s.begin(), ::toupper); -} - -std::string JoinString(const std::vector& ar, const std::string &delim) { - std::string ret; - for (size_t i = 0; i < ar.size(); ++i) { - if (i != 0) { - ret += delim; - } - - ret += ar[i]; - } - - return ret; -} - -void find_replace(std::string &string_subject, const std::string &search_string, const std::string &replace_string) -{ - if (string_subject.find(search_string) == std::string::npos) { - return; - } - - size_t start_pos = 0; - while((start_pos = string_subject.find(search_string, start_pos)) != std::string::npos) { - string_subject.replace(start_pos, search_string.length(), replace_string); - start_pos += replace_string.length(); - } - -} - -void ParseAccountString(const std::string &s, std::string &account, std::string &loginserver) -{ - auto split = SplitString(s, ':'); - if (split.size() == 2) { - loginserver = split[0]; - account = split[1]; - } - else if(split.size() == 1) { - account = split[0]; - } -} - -//Const char based - -// normal strncpy doesnt put a null term on copied strings, this one does -// ref: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wcecrt/htm/_wcecrt_strncpy_wcsncpy.asp -char* strn0cpy(char* dest, const char* source, uint32 size) { - if (!dest) - return 0; - if (size == 0 || source == 0) { - dest[0] = 0; - return dest; - } - strncpy(dest, source, size); - dest[size - 1] = 0; - return dest; -} - -// String N w/null Copy Truncated? -// return value =true if entire string(source) fit, false if it was truncated -bool strn0cpyt(char* dest, const char* source, uint32 size) { - if (!dest) - return 0; - if (size == 0 || source == 0) { - dest[0] = 0; - return false; - } - strncpy(dest, source, size); - dest[size - 1] = 0; - return (bool)(source[strlen(dest)] == 0); -} - -const char *MakeLowerString(const char *source) { - static char str[128]; - if (!source) - return nullptr; - MakeLowerString(source, str); - return str; -} - -void MakeLowerString(const char *source, char *target) { - if (!source || !target) { - *target = 0; - return; - } - while (*source) - { - *target = tolower(*source); - target++; source++; - } - *target = 0; -} - -int MakeAnyLenString(char** ret, const char* format, ...) { - int buf_len = 128; - int chars = -1; - va_list argptr, tmpargptr; - va_start(argptr, format); - while (chars == -1 || chars >= buf_len) { - safe_delete_array(*ret); - if (chars == -1) - buf_len *= 2; - else - buf_len = chars + 1; - *ret = new char[buf_len]; - va_copy(tmpargptr, argptr); - chars = vsnprintf(*ret, buf_len, format, tmpargptr); - } - va_end(argptr); - return chars; -} - -uint32 AppendAnyLenString(char** ret, uint32* bufsize, uint32* strlen, const char* format, ...) { - if (*bufsize == 0) - *bufsize = 256; - if (*ret == 0) - *strlen = 0; - int chars = -1; - char* oldret = 0; - va_list argptr, tmpargptr; - va_start(argptr, format); - while (chars == -1 || chars >= (int32)(*bufsize - *strlen)) { - if (chars == -1) - *bufsize += 256; - else - *bufsize += chars + 25; - oldret = *ret; - *ret = new char[*bufsize]; - if (oldret) { - if (*strlen) - memcpy(*ret, oldret, *strlen); - safe_delete_array(oldret); - } - va_copy(tmpargptr, argptr); - chars = vsnprintf(&(*ret)[*strlen], (*bufsize - *strlen), format, tmpargptr); - } - va_end(argptr); - *strlen += chars; - return *strlen; -} - -uint32 hextoi(const char* num) { - if (num == nullptr) - return 0; - - int len = strlen(num); - if (len < 3) - return 0; - - if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X')) - return 0; - - uint32 ret = 0; - int mul = 1; - for (int i = len - 1; i >= 2; i--) { - if (num[i] >= 'A' && num[i] <= 'F') - ret += ((num[i] - 'A') + 10) * mul; - else if (num[i] >= 'a' && num[i] <= 'f') - ret += ((num[i] - 'a') + 10) * mul; - else if (num[i] >= '0' && num[i] <= '9') - ret += (num[i] - '0') * mul; - else - return 0; - mul *= 16; - } - return ret; -} - -uint64 hextoi64(const char* num) { - if (num == nullptr) - return 0; - - int len = strlen(num); - if (len < 3) - return 0; - - if (num[0] != '0' || (num[1] != 'x' && num[1] != 'X')) - return 0; - - uint64 ret = 0; - int mul = 1; - for (int i = len - 1; i >= 2; i--) { - if (num[i] >= 'A' && num[i] <= 'F') - ret += ((num[i] - 'A') + 10) * mul; - else if (num[i] >= 'a' && num[i] <= 'f') - ret += ((num[i] - 'a') + 10) * mul; - else if (num[i] >= '0' && num[i] <= '9') - ret += (num[i] - '0') * mul; - else - return 0; - mul *= 16; - } - return ret; -} - -bool atobool(const char* iBool) { - - if (iBool == nullptr) - return false; - if (!strcasecmp(iBool, "true")) - return true; - if (!strcasecmp(iBool, "false")) - return false; - if (!strcasecmp(iBool, "yes")) - return true; - if (!strcasecmp(iBool, "no")) - return false; - if (!strcasecmp(iBool, "on")) - return true; - if (!strcasecmp(iBool, "off")) - return false; - if (!strcasecmp(iBool, "enable")) - return true; - if (!strcasecmp(iBool, "disable")) - return false; - if (!strcasecmp(iBool, "enabled")) - return true; - if (!strcasecmp(iBool, "disabled")) - return false; - if (!strcasecmp(iBool, "y")) - return true; - if (!strcasecmp(iBool, "n")) - return false; - if (atoi(iBool)) - return true; - return false; -} - -// removes the crap and turns the underscores into spaces. -char *CleanMobName(const char *in, char *out) -{ - unsigned i, j; - - for (i = j = 0; i < strlen(in); i++) - { - // convert _ to space.. any other conversions like this? I *think* this - // is the only non alpha char that's not stripped but converted. - if (in[i] == '_') - { - out[j++] = ' '; - } - else - { - if (isalpha(in[i]) || (in[i] == '`')) // numbers, #, or any other crap just gets skipped - out[j++] = in[i]; - } - } - out[j] = 0; // terimnate the string before returning it - return out; -} - - -void RemoveApostrophes(std::string &s) -{ - for (unsigned int i = 0; i < s.length(); ++i) - if (s[i] == '\'') - s[i] = '_'; -} - -char *RemoveApostrophes(const char *s) -{ - auto NewString = new char[strlen(s) + 1]; - - strcpy(NewString, s); - - for (unsigned int i = 0; i < strlen(NewString); ++i) - if (NewString[i] == '\'') - NewString[i] = '_'; - - return NewString; -} - -const char *ConvertArray(int input, char *returnchar) -{ - sprintf(returnchar, "%i", input); - return returnchar; -} - -const char *ConvertArrayF(float input, char *returnchar) -{ - sprintf(returnchar, "%0.2f", input); - return returnchar; -} - -bool isAlphaNumeric(const char *text) -{ - for (unsigned int charIndex = 0; charIndex 'z') && - (text[charIndex] < 'A' || text[charIndex] > 'Z') && - (text[charIndex] < '0' || text[charIndex] > '9')) - return false; - } - - return true; -} diff --git a/source/common/string_util.h b/source/common/string_util.h deleted file mode 100644 index 037d6a2..0000000 --- a/source/common/string_util.h +++ /dev/null @@ -1,193 +0,0 @@ -/* - * Copyright 2013 Facebook, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef _STRINGUTIL_H_ -#define _STRINGUTIL_H_ - -#include -#include -#include -#include -#include - -#ifndef _WIN32 -// this doesn't appear to affect linux-based systems..need feedback for _WIN64 -#include -#endif - -#ifdef _WINDOWS -#include -#include -#include -#endif - -#include "types.h" - -//std::string based -const std::string str_tolower(std::string s); -const std::string str_toupper(std::string s); -const std::string ucfirst(std::string s); -std::vector split(std::string str_to_split, char delimiter); -const std::string StringFormat(const char* format, ...); -const std::string vStringFormat(const char* format, va_list args); -std::string implode(std::string glue, std::vector src); - -/** - * @param str - * @param chars - * @return - */ -inline std::string <rim(std::string &str, const std::string &chars = "\t\n\v\f\r ") -{ - str.erase(0, str.find_first_not_of(chars)); - return str; -} - -/** - * @param str - * @param chars - * @return - */ -inline std::string &rtrim(std::string &str, const std::string &chars = "\t\n\v\f\r ") -{ - str.erase(str.find_last_not_of(chars) + 1); - return str; -} - -/** - * @param str - * @param chars - * @return - */ -inline std::string &trim(std::string &str, const std::string &chars = "\t\n\v\f\r ") -{ - return ltrim(rtrim(str, chars), chars); -} - -template -std::string implode(const std::string &glue, const std::pair &encapsulation, const std::vector &src) -{ - if (src.empty()) { - return {}; - } - - std::ostringstream oss; - - for (const T &src_iter : src) { - oss << encapsulation.first << src_iter << encapsulation.second << glue; - } - - std::string output(oss.str()); - output.resize(output.size() - glue.size()); - - return output; -} - -// _WIN32 builds require that #include be included in whatever code file the invocation is made from (no header files) -template -std::vector join_pair(const std::string &glue, const std::pair &encapsulation, const std::vector> &src) -{ - if (src.empty()) { - return {}; - } - - std::vector output; - - for (const std::pair &src_iter : src) { - output.push_back( - - fmt::format( - "{}{}{}{}{}{}{}", - encapsulation.first, - src_iter.first, - encapsulation.second, - glue, - encapsulation.first, - src_iter.second, - encapsulation.second - ) - ); - } - - return output; -} - -// _WIN32 builds require that #include be included in whatever code file the invocation is made from (no header files) -template -std::vector join_tuple(const std::string &glue, const std::pair &encapsulation, const std::vector> &src) -{ - if (src.empty()) { - return {}; - } - - std::vector output; - - for (const std::tuple &src_iter : src) { - - output.push_back( - - fmt::format( - "{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", - encapsulation.first, - std::get<0>(src_iter), - encapsulation.second, - glue, - encapsulation.first, - std::get<1>(src_iter), - encapsulation.second, - glue, - encapsulation.first, - std::get<2>(src_iter), - encapsulation.second, - glue, - encapsulation.first, - std::get<3>(src_iter), - encapsulation.second - ) - ); - } - - return output; -} - -std::vector SplitString(const std::string &s, char delim); -std::string EscapeString(const char *src, size_t sz); -std::string EscapeString(const std::string &s); -bool StringIsNumber(const std::string &s); -void ToLowerString(std::string &s); -void ToUpperString(std::string &s); -std::string JoinString(const std::vector& ar, const std::string &delim); -void find_replace(std::string& string_subject, const std::string& search_string, const std::string& replace_string); -void ParseAccountString(const std::string &s, std::string &account, std::string &loginserver); - -//const char based - -bool atobool(const char* iBool); -bool isAlphaNumeric(const char *text); -bool strn0cpyt(char* dest, const char* source, uint32 size); -char *CleanMobName(const char *in, char *out); -char *RemoveApostrophes(const char *s); -char* strn0cpy(char* dest, const char* source, uint32 size); -const char *ConvertArray(int input, char *returnchar); -const char *ConvertArrayF(float input, char *returnchar); -const char *MakeLowerString(const char *source); -int MakeAnyLenString(char** ret, const char* format, ...); -uint32 AppendAnyLenString(char** ret, uint32* bufsize, uint32* strlen, const char* format, ...); -uint32 hextoi(const char* num); -uint64 hextoi64(const char* num); -void MakeLowerString(const char *source, char *target); -void RemoveApostrophes(std::string &s); - -#endif diff --git a/source/common/timer.cpp b/source/common/timer.cpp deleted file mode 100644 index e9c08ef..0000000 --- a/source/common/timer.cpp +++ /dev/null @@ -1,207 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "../common/debug.h" -// Disgrace: for windows compile -#ifndef WIN32 - #include -#else - #include -#endif - -#include -using namespace std; - -#include "timer.h" - -int32 started_unix_timestamp = 0; -int32 current_time = 0; -int32 last_time = 0; - -Timer::Timer(){ - timer_time = 30000; //default to 30 seconds - start_time = current_time; - set_at_trigger = timer_time; - pUseAcurateTiming = false; - enabled = false; -} -Timer::Timer(int32 in_timer_time, bool iUseAcurateTiming) { - timer_time = in_timer_time; - start_time = current_time; - set_at_trigger = timer_time; - pUseAcurateTiming = iUseAcurateTiming; - if (timer_time == 0) { - enabled = false; - } - else { - enabled = true; - } -} - -Timer::Timer(int32 start, int32 timer, bool iUseAcurateTiming = false) { - timer_time = timer; - start_time = start; - set_at_trigger = timer_time; - pUseAcurateTiming = iUseAcurateTiming; - if (timer_time == 0) { - enabled = false; - } - else { - enabled = true; - } -} - -/* Reimplemented for MSVC - Bounce */ -#ifdef WIN32 -int gettimeofday (timeval *tp, ...) -{ - timeb tb; - - ftime (&tb); - - tp->tv_sec = tb.time; - tp->tv_usec = tb.millitm * 1000; - - return 0; -} -#endif - -/* This function checks if the timer triggered */ -bool Timer::Check(bool iReset) -{ - if (enabled && current_time-start_time > timer_time) { - if (iReset) { - if (pUseAcurateTiming) - start_time += timer_time; - else - start_time = current_time; // Reset timer - timer_time = set_at_trigger; - } - return true; - } - - return false; -} - -/* This function disables the timer */ -void Timer::Disable() { - enabled = false; -} - -void Timer::Enable() { - enabled = true; -} - -/* This function set the timer and restart it */ -void Timer::Start(int32 set_timer_time, bool ChangeResetTimer) { - start_time = current_time; - enabled = true; - if (set_timer_time != 0) - { - timer_time = set_timer_time; - if (ChangeResetTimer) - set_at_trigger = set_timer_time; - } -} - -/* This timer updates the timer without restarting it */ -void Timer::SetTimer(int32 set_timer_time) { - /* If we were disabled before => restart the timer */ - if (!enabled) { - start_time = current_time; - enabled = true; - } - if (set_timer_time != 0) { - timer_time = set_timer_time; - set_at_trigger = set_timer_time; - } -} - -int32 Timer::GetElapsedTime(){ - if (enabled) { - return current_time - start_time; - } - else { - return 0xFFFFFFFF; - } -} - -int32 Timer::GetRemainingTime() { - if (enabled) { - if (current_time-start_time > timer_time) - return 0; - else - return (start_time + timer_time) - current_time; - } - else { - return 0xFFFFFFFF; - } -} - -void Timer::SetAtTrigger(int32 in_set_at_trigger, bool iEnableIfDisabled) { - set_at_trigger = in_set_at_trigger; - if (!Enabled() && iEnableIfDisabled) { - Enable(); - } -} - -void Timer::Trigger() -{ - enabled = true; - - timer_time = set_at_trigger; - start_time = current_time-timer_time-1; -} - -const int32& Timer::GetCurrentTime2() -{ - return current_time; -} - -const int32& Timer::SetCurrentTime() -{ - struct timeval read_time; - int32 this_time; - - gettimeofday(&read_time,0); - if(started_unix_timestamp == 0) - started_unix_timestamp = read_time.tv_sec; - - this_time = (read_time.tv_sec - started_unix_timestamp) * 1000 + read_time.tv_usec / 1000; - - if (last_time == 0) - { - current_time = 0; - } - else - { - current_time += this_time - last_time; - } - - last_time = this_time; - -// cerr << "Current time:" << current_time << endl; - return current_time; -} - -int32 Timer::GetUnixTimeStamp(){ - struct timeval read_time; - gettimeofday(&read_time,0); - return read_time.tv_sec; -} diff --git a/source/common/timer.h b/source/common/timer.h deleted file mode 100644 index a70a2d2..0000000 --- a/source/common/timer.h +++ /dev/null @@ -1,88 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef TIMER_H -#define TIMER_H - -#include "types.h" -#include - -// Disgrace: for windows compile -#ifdef WIN32 - #include - #include - int gettimeofday (timeval *tp, ...); -#endif - -class Timer -{ -public: - Timer(); - Timer(int32 timer_time, bool iUseAcurateTiming = false); - Timer(int32 start, int32 timer, bool iUseAcurateTiming); - ~Timer() { } - - bool Check(bool iReset = true); - void Enable(); - void Disable(); - void Start(int32 set_timer_time=0, bool ChangeResetTimer = true); - void SetTimer(int32 set_timer_time=0); - int32 GetRemainingTime(); - int32 GetElapsedTime(); - inline const int32& GetTimerTime() { return timer_time; } - inline const int32& GetSetAtTrigger() { return set_at_trigger; } - void Trigger(); - void SetAtTrigger(int32 set_at_trigger, bool iEnableIfDisabled = false); - - inline bool Enabled() { return enabled; } - inline int32 GetStartTime() { return(start_time); } - inline int32 GetDuration() { return(timer_time); } - - static const int32& SetCurrentTime(); - static const int32& GetCurrentTime2(); - static int32 GetUnixTimeStamp(); - -private: - int32 start_time; - int32 timer_time; - bool enabled; - int32 set_at_trigger; - - // Tells the timer to be more acurate about happening every X ms. - // Instead of Check() setting the start_time = now, - // it it sets it to start_time += timer_time - bool pUseAcurateTiming; - -// static int32 current_time; -// static int32 last_time; -}; - -struct BenchTimer -{ - typedef std::chrono::high_resolution_clock clock; - - BenchTimer() : start_time(clock::now()) {} - void reset() { start_time = clock::now(); } - // this is seconds - double elapsed() { return std::chrono::duration(clock::now() - start_time).count(); } -private: - std::chrono::time_point start_time; -}; - -#endif diff --git a/source/common/unix.cpp b/source/common/unix.cpp deleted file mode 100644 index 6476c3a..0000000 --- a/source/common/unix.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#include "unix.h" -#include -#include - -void Sleep(unsigned int x) { - if (x > 0) - usleep(x*1000); -} - -char* strupr(char* tmp) { - int l = strlen(tmp); - for (int x = 0; x < l; x++) { - tmp[x] = toupper(tmp[x]); - } - return tmp; -} - -char* strlwr(char* tmp) { - int l = strlen(tmp); - for (int x = 0; x < l; x++) { - tmp[x] = tolower(tmp[x]); - } - return tmp; -} - - diff --git a/source/common/unix.h b/source/common/unix.h deleted file mode 100644 index 82560a1..0000000 --- a/source/common/unix.h +++ /dev/null @@ -1,34 +0,0 @@ -/* - EQ2Emulator: Everquest II Server Emulator - Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - - This file is part of EQ2Emulator. - - EQ2Emulator is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - EQ2Emulator is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with EQ2Emulator. If not, see . -*/ -#ifndef WIN32 -#ifndef __UNIX_H__ -#define __UNIX_H__ - #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP - #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, __LOCK_INITIALIZER} - #endif -#include - -typedef int SOCKET; - -void Sleep(unsigned int x); -char* strupr(char* tmp); -char* strlwr(char* tmp); -#endif -#endif diff --git a/source/common/xmlParser.cpp b/source/common/xmlParser.cpp deleted file mode 100644 index e0f7f33..0000000 --- a/source/common/xmlParser.cpp +++ /dev/null @@ -1,2974 +0,0 @@ -/** - **************************************************************************** - *

XML.c - implementation file for basic XML parser written in ANSI C++ - * for portability. It works by using recursion and a node tree for breaking - * down the elements of an XML document.

- * - * @version V2.44 - * @author Frank Vanden Berghen - * - * NOTE: - * - * If you add "#define STRICT_PARSING", on the first line of this file - * the parser will see the following XML-stream: - * some textother text - * as an error. Otherwise, this tring will be equivalent to: - * some textother text - * - * NOTE: - * - * If you add "#define APPROXIMATE_PARSING" on the first line of this file - * the parser will see the following XML-stream: - * - * - * - * as equivalent to the following XML-stream: - * - * - * - * This can be useful for badly-formed XML-streams but prevent the use - * of the following XML-stream (problem is: tags at contiguous levels - * have the same names): - * - * - * - * - * - * - * NOTE: - * - * If you add "#define _XMLPARSER_NO_MESSAGEBOX_" on the first line of this file - * the "openFileHelper" function will always display error messages inside the - * console instead of inside a message-box-window. Message-box-windows are - * available on windows 9x/NT/2000/XP/Vista only. - * - * Copyright (c) 2002, Frank Vanden Berghen - All rights reserved. - * Commercialized by Business-Insight - * See the file "AFPL-license.txt about the licensing terms - * - **************************************************************************** - */ -#ifndef _CRT_SECURE_NO_DEPRECATE -#define _CRT_SECURE_NO_DEPRECATE -#endif -#include "xmlParser.h" -#ifdef _XMLWINDOWS -//#ifdef _DEBUG -//#define _CRTDBG_MAP_ALLOC -//#include -//#endif -#define WIN32_LEAN_AND_MEAN -#include // to have IsTextUnicode, MultiByteToWideChar, WideCharToMultiByte to handle unicode files - // to have "MessageBoxA" to display error messages for openFilHelper -#endif - -#include -#include -#include -#include -#include - -XMLCSTR XMLNode::getVersion() { return _CXML("v2.44"); } -void freeXMLString(XMLSTR t){if(t)free(t);} - -static XMLNode::XMLCharEncoding characterEncoding=XMLNode::char_encoding_UTF8; -static char guessWideCharChars=1, dropWhiteSpace=1, removeCommentsInMiddleOfText=1; - -inline int mmin( const int t1, const int t2 ) { return t1 < t2 ? t1 : t2; } - -// You can modify the initialization of the variable "XMLClearTags" below -// to change the clearTags that are currently recognized by the library. -// The number on the second columns is the length of the string inside the -// first column. -// The "") }, - { _CXML("") }, - { _CXML("") }, - { _CXML("
")    ,5,  _CXML("
") }, -// { _CXML("")}, - { NULL ,0, NULL } -}; - -// You can modify the initialization of the variable "XMLEntities" below -// to change the character entities that are currently recognized by the library. -// The number on the second columns is the length of the string inside the -// first column. Additionally, the syntaxes " " and " " are recognized. -typedef struct { XMLCSTR s; int l; XMLCHAR c;} XMLCharacterEntity; -static XMLCharacterEntity XMLEntities[] = -{ - { _CXML("&" ), 5, _CXML('&' )}, - { _CXML("<" ), 4, _CXML('<' )}, - { _CXML(">" ), 4, _CXML('>' )}, - { _CXML("""), 6, _CXML('\"')}, - { _CXML("'"), 6, _CXML('\'')}, - { NULL , 0, '\0' } -}; - -// When rendering the XMLNode to a string (using the "createXMLString" function), -// you can ask for a beautiful formatting. This formatting is using the -// following indentation character: -#define INDENTCHAR _CXML('\t') - -// The following function parses the XML errors into a user friendly string. -// You can edit this to change the output language of the library to something else. -XMLCSTR XMLNode::getError(XMLError xerror) -{ - switch (xerror) - { - case eXMLErrorNone: return _CXML("No error"); - case eXMLErrorMissingEndTag: return _CXML("Warning: Unmatched end tag"); - case eXMLErrorNoXMLTagFound: return _CXML("Warning: No XML tag found"); - case eXMLErrorEmpty: return _CXML("Error: No XML data"); - case eXMLErrorMissingTagName: return _CXML("Error: Missing start tag name"); - case eXMLErrorMissingEndTagName: return _CXML("Error: Missing end tag name"); - case eXMLErrorUnmatchedEndTag: return _CXML("Error: Unmatched end tag"); - case eXMLErrorUnmatchedEndClearTag: return _CXML("Error: Unmatched clear tag end"); - case eXMLErrorUnexpectedToken: return _CXML("Error: Unexpected token found"); - case eXMLErrorNoElements: return _CXML("Error: No elements found"); - case eXMLErrorFileNotFound: return _CXML("Error: File not found"); - case eXMLErrorFirstTagNotFound: return _CXML("Error: First Tag not found"); - case eXMLErrorUnknownCharacterEntity:return _CXML("Error: Unknown character entity"); - case eXMLErrorCharacterCodeAbove255: return _CXML("Error: Character code above 255 is forbidden in MultiByte char mode."); - case eXMLErrorCharConversionError: return _CXML("Error: unable to convert between WideChar and MultiByte chars"); - case eXMLErrorCannotOpenWriteFile: return _CXML("Error: unable to open file for writing"); - case eXMLErrorCannotWriteFile: return _CXML("Error: cannot write into file"); - - case eXMLErrorBase64DataSizeIsNotMultipleOf4: return _CXML("Warning: Base64-string length is not a multiple of 4"); - case eXMLErrorBase64DecodeTruncatedData: return _CXML("Warning: Base64-string is truncated"); - case eXMLErrorBase64DecodeIllegalCharacter: return _CXML("Error: Base64-string contains an illegal character"); - case eXMLErrorBase64DecodeBufferTooSmall: return _CXML("Error: Base64 decode output buffer is too small"); - }; - return _CXML("Unknown"); -} - -///////////////////////////////////////////////////////////////////////// -// Here start the abstraction layer to be OS-independent // -///////////////////////////////////////////////////////////////////////// - -// Here is an abstraction layer to access some common string manipulation functions. -// The abstraction layer is currently working for gcc, Microsoft Visual Studio 6.0, -// Microsoft Visual Studio .NET, CC (sun compiler) and Borland C++. -// If you plan to "port" the library to a new system/compiler, all you have to do is -// to edit the following lines. -#ifdef XML_NO_WIDE_CHAR -char myIsTextWideChar(const void *b, int len) { return FALSE; } -#else - #if defined (UNDER_CE) || !defined(_XMLWINDOWS) - char myIsTextWideChar(const void *b, int len) // inspired by the Wine API: RtlIsTextUnicode - { -#ifdef sun - // for SPARC processors: wchar_t* buffers must always be alligned, otherwise it's a char* buffer. - if ((((unsigned long)b)%sizeof(wchar_t))!=0) return FALSE; -#endif - const wchar_t *s=(const wchar_t*)b; - - // buffer too small: - if (len<(int)sizeof(wchar_t)) return FALSE; - - // odd length test - if (len&1) return FALSE; - - /* only checks the first 256 characters */ - len=mmin(256,len/sizeof(wchar_t)); - - // Check for the special byte order: - if (*((unsigned short*)s) == 0xFFFE) return TRUE; // IS_TEXT_UNICODE_REVERSE_SIGNATURE; - if (*((unsigned short*)s) == 0xFEFF) return TRUE; // IS_TEXT_UNICODE_SIGNATURE - - // checks for ASCII characters in the UNICODE stream - int i,stats=0; - for (i=0; ilen/2) return TRUE; - - // Check for UNICODE NULL chars - for (i=0; i - static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncasecmp(c1,c2,l);} - static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncmp(c1,c2,l);} - static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return wscasecmp(c1,c2); } - #else - static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncmp(c1,c2,l);} - #ifdef __linux__ - // for gcc/linux - static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncasecmp(c1,c2,l);} - static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return wcscasecmp(c1,c2); } - #else - #include - // for gcc/non-linux (MacOS X 10.3, FreeBSD 6.0, NetBSD 3.0, OpenBSD 3.8, AIX 4.3.2, HP-UX 11, IRIX 6.5, OSF/1 5.1, Cygwin, mingw) - static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) - { - wchar_t left,right; - do - { - left=towlower(*c1++); right=towlower(*c2++); - } while (left&&(left==right)); - return (int)left-(int)right; - } - static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) - { - wchar_t left,right; - while(l--) - { - left=towlower(*c1++); right=towlower(*c2++); - if ((!left)||(left!=right)) return (int)left-(int)right; - } - return 0; - } - #endif - #endif - static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)wcsstr(c1,c2); } - static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)wcscpy(c1,c2); } - static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode) - { - char *filenameAscii=myWideCharToMultiByte(filename); - FILE *f; - if (mode[0]==_CXML('r')) f=fopen(filenameAscii,"rb"); - else f=fopen(filenameAscii,"wb"); - free(filenameAscii); - return f; - } - #else - static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); } - static inline int xstrlen(XMLCSTR c) { return strlen(c); } - static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncasecmp(c1,c2,l);} - static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncmp(c1,c2,l);} - static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return strcasecmp(c1,c2); } - static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); } - static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); } - #endif - static inline int _strnicmp(const char *c1,const char *c2, int l) { return strncasecmp(c1,c2,l);} -#endif - - -/////////////////////////////////////////////////////////////////////////////// -// the "xmltoc,xmltob,xmltoi,xmltol,xmltof,xmltoa" functions // -/////////////////////////////////////////////////////////////////////////////// -// These 6 functions are not used inside the XMLparser. -// There are only here as "convenience" functions for the user. -// If you don't need them, you can delete them without any trouble. -#ifdef _XMLWIDECHAR - #ifdef _XMLWINDOWS - // for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET and Borland C++ Builder 6.0 - char xmltob(XMLCSTR t,char v){ if (t&&(*t)) return (char)_wtoi(t); return v; } - int xmltoi(XMLCSTR t,int v){ if (t&&(*t)) return _wtoi(t); return v; } - long long xmltol(XMLCSTR t,long long v){ if (t&&(*t)) return _wtoi64(t); return v; } - double xmltof(XMLCSTR t,double v){ if (t&&(*t)) swscanf(t, L"%lf", &v); /*v=_wtof(t);*/ return v; } - #else - #ifdef sun - // for CC - #include - char xmltob(XMLCSTR t,char v){ if (t) return (char)wstol(t,NULL,10); return v; } - int xmltoi(XMLCSTR t,int v){ if (t) return (int)wstol(t,NULL,10); return v; } - long long xmltol(XMLCSTR t,long long v){ if (t) return wstol(t,NULL,10); return v; } - #else - // for gcc - char xmltob(XMLCSTR t,char v){ if (t) return (char)wcstol(t,NULL,10); return v; } - int xmltoi(XMLCSTR t,int v){ if (t) return (int)wcstol(t,NULL,10); return v; } - long long xmltol(XMLCSTR t,long long v){ if (t) return wcstol(t,NULL,10); return v; } - #endif - double xmltof(XMLCSTR t,double v){ if (t&&(*t)) swscanf(t, L"%lf", &v); /*v=_wtof(t);*/ return v; } - #endif -#else - #ifdef _XMLWINDOWS - long long xmltol(XMLCSTR t,long long v){ if (t&&(*t)) return _atoi64(t); return v; } - #else - long long xmltol(XMLCSTR t,long long v){ if (t&&(*t)) return atoll(t); return v; } - #endif - char xmltob(XMLCSTR t,char v){ if (t&&(*t)) return (char)atoi(t); return v; } - int xmltoi(XMLCSTR t,int v){ if (t&&(*t)) return atoi(t); return v; } - double xmltof(XMLCSTR t,double v){ if (t&&(*t)) return atof(t); return v; } -#endif -XMLCSTR xmltoa(XMLCSTR t, XMLCSTR v){ if (t) return t; return v; } -XMLCHAR xmltoc(XMLCSTR t,const XMLCHAR v){ if (t&&(*t)) return *t; return v; } - -///////////////////////////////////////////////////////////////////////// -// the "openFileHelper" function // -///////////////////////////////////////////////////////////////////////// - -// Since each application has its own way to report and deal with errors, you should modify & rewrite -// the following "openFileHelper" function to get an "error reporting mechanism" tailored to your needs. -XMLNode XMLNode::openFileHelper(XMLCSTR filename, XMLCSTR tag) -{ - // guess the value of the global parameter "characterEncoding" - // (the guess is based on the first 200 bytes of the file). - FILE *f=xfopen(filename,_CXML("rb")); - if (f) - { - char bb[205]; - int l=(int)fread(bb,1,200,f); - setGlobalOptions(guessCharEncoding(bb,l),guessWideCharChars,dropWhiteSpace,removeCommentsInMiddleOfText); - fclose(f); - } - - // parse the file - XMLResults pResults; - XMLNode xnode=XMLNode::parseFile(filename,tag,&pResults); - - // display error message (if any) - if (pResults.error != eXMLErrorNone) - { - // create message - char message[2000],*s1=(char*)"",*s3=(char*)""; XMLCSTR s2=_CXML(""); - if (pResults.error==eXMLErrorFirstTagNotFound) { s1=(char*)"First Tag should be '"; s2=tag; s3=(char*)"'.\n"; } -#ifdef _XMLWINDOWS - _snprintf(message,2000, -#else - snprintf(message,2000, -#endif -#ifdef _XMLWIDECHAR - "XML Parsing error inside file '%S'.\n%S\nAt line %i, column %i.\n%s%S%s" -#else - "XML Parsing error inside file '%s'.\n%s\nAt line %i, column %i.\n%s%s%s" -#endif - ,filename,XMLNode::getError(pResults.error),pResults.nLine,pResults.nColumn,s1,s2,s3); - - // display message -#if defined(_XMLWINDOWS) && !defined(UNDER_CE) && !defined(_XMLPARSER_NO_MESSAGEBOX_) - MessageBoxA(NULL,message,"XML Parsing error",MB_OK|MB_ICONERROR|MB_TOPMOST); -#else - printf("%s",message); -#endif - exit(255); - } - return xnode; -} - -///////////////////////////////////////////////////////////////////////// -// Here start the core implementation of the XMLParser library // -///////////////////////////////////////////////////////////////////////// - -// You should normally not change anything below this point. - -#ifndef _XMLWIDECHAR -// If "characterEncoding=ascii" then we assume that all characters have the same length of 1 byte. -// If "characterEncoding=UTF8" then the characters have different lengths (from 1 byte to 4 bytes). -// If "characterEncoding=ShiftJIS" then the characters have different lengths (from 1 byte to 2 bytes). -// This table is used as lookup-table to know the length of a character (in byte) based on the -// content of the first byte of the character. -// (note: if you modify this, you must always have XML_utf8ByteTable[0]=0 ). -static const char XML_utf8ByteTable[256] = -{ - // 0 1 2 3 4 5 6 7 8 9 a b c d e f - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70 End of ASCII range - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x80 0x80 to 0xc1 invalid - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x90 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0 - 1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0 0xc2 to 0xdf 2 byte - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0 - 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,// 0xe0 0xe0 to 0xef 3 byte - 4,4,4,4,4,1,1,1,1,1,1,1,1,1,1,1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid -}; -static const char XML_legacyByteTable[256] = -{ - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 -}; -static const char XML_sjisByteTable[256] = -{ - // 0 1 2 3 4 5 6 7 8 9 a b c d e f - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70 - 1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x80 0x81 to 0x9F 2 bytes - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x90 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xc0 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xd0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xe0 0xe0 to 0xef 2 bytes - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 // 0xf0 -}; -static const char XML_gb2312ByteTable[256] = -{ -// 0 1 2 3 4 5 6 7 8 9 a b c d e f - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x80 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x90 - 1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xa0 0xa1 to 0xf7 2 bytes - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xb0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xe0 - 2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1 // 0xf0 -}; -static const char XML_gbk_big5_ByteTable[256] = -{ - // 0 1 2 3 4 5 6 7 8 9 a b c d e f - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70 - 1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x80 0x81 to 0xfe 2 bytes - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x90 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xa0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xb0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xe0 - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1 // 0xf0 -}; -static const char *XML_ByteTable=(const char *)XML_utf8ByteTable; // the default is "characterEncoding=XMLNode::encoding_UTF8" -#endif - - -XMLNode XMLNode::emptyXMLNode; -XMLClear XMLNode::emptyXMLClear={ NULL, NULL, NULL}; -XMLAttribute XMLNode::emptyXMLAttribute={ NULL, NULL}; - -// Enumeration used to decipher what type a token is -typedef enum XMLTokenTypeTag -{ - eTokenText = 0, - eTokenQuotedText, - eTokenTagStart, /* "<" */ - eTokenTagEnd, /* "" */ - eTokenEquals, /* "=" */ - eTokenDeclaration, /* "" */ - eTokenClear, - eTokenError -} XMLTokenType; - -// Main structure used for parsing XML -typedef struct XML -{ - XMLCSTR lpXML; - XMLCSTR lpszText; - int nIndex,nIndexMissigEndTag; - enum XMLError error; - XMLCSTR lpEndTag; - int cbEndTag; - XMLCSTR lpNewElement; - int cbNewElement; - int nFirst; -} XML; - -typedef struct -{ - ALLXMLClearTag *pClr; - XMLCSTR pStr; -} NextToken; - -// Enumeration used when parsing attributes -typedef enum Attrib -{ - eAttribName = 0, - eAttribEquals, - eAttribValue -} Attrib; - -// Enumeration used when parsing elements to dictate whether we are currently -// inside a tag -typedef enum XMLStatus -{ - eInsideTag = 0, - eOutsideTag -} XMLStatus; - -XMLError XMLNode::writeToFile(XMLCSTR filename, const char *encoding, char nFormat) const -{ - if (!d) return eXMLErrorNone; - FILE *f=xfopen(filename,_CXML("wb")); - if (!f) return eXMLErrorCannotOpenWriteFile; -#ifdef _XMLWIDECHAR - unsigned char h[2]={ 0xFF, 0xFE }; - if (!fwrite(h,2,1,f)) - { - fclose(f); - return eXMLErrorCannotWriteFile; - } - if ((!isDeclaration())&&((d->lpszName)||(!getChildNode().isDeclaration()))) - { - if (!fwrite(L"\n",sizeof(wchar_t)*40,1,f)) - { - fclose(f); - return eXMLErrorCannotWriteFile; - } - } -#else - if ((!isDeclaration())&&((d->lpszName)||(!getChildNode().isDeclaration()))) - { - if (characterEncoding==char_encoding_UTF8) - { - // header so that windows recognize the file as UTF-8: - unsigned char h[3]={0xEF,0xBB,0xBF}; - if (!fwrite(h,3,1,f)) - { - fclose(f); - return eXMLErrorCannotWriteFile; - } - encoding="utf-8"; - } else if (characterEncoding==char_encoding_ShiftJIS) encoding="SHIFT-JIS"; - - if (!encoding) encoding="ISO-8859-1"; - if (fprintf(f,"\n",encoding)<0) - { - fclose(f); - return eXMLErrorCannotWriteFile; - } - } else - { - if (characterEncoding==char_encoding_UTF8) - { - unsigned char h[3]={0xEF,0xBB,0xBF}; - if (!fwrite(h,3,1,f)) - { - fclose(f); - return eXMLErrorCannotWriteFile; - } - } - } -#endif - int i; - XMLSTR t=createXMLString(nFormat,&i); - if (!fwrite(t,sizeof(XMLCHAR)*i,1,f)) - { - free(t); - fclose(f); - return eXMLErrorCannotWriteFile; - } - if (fclose(f)!=0) - { - free(t); - return eXMLErrorCannotWriteFile; - } - free(t); - return eXMLErrorNone; -} - -// Duplicate a given string. -XMLSTR stringDup(XMLCSTR lpszData, int cbData) -{ - if (lpszData==NULL) return NULL; - - XMLSTR lpszNew; - if (cbData==-1) cbData=(int)xstrlen(lpszData); - lpszNew = (XMLSTR)malloc((cbData+1) * sizeof(XMLCHAR)); - if (lpszNew) - { - memcpy(lpszNew, lpszData, (cbData) * sizeof(XMLCHAR)); - lpszNew[cbData] = (XMLCHAR)NULL; - } - return lpszNew; -} - -XMLSTR ToXMLStringTool::toXMLUnSafe(XMLSTR dest,XMLCSTR source) -{ - XMLSTR dd=dest; - XMLCHAR ch; - XMLCharacterEntity *entity; - while ((ch=*source)) - { - entity=XMLEntities; - do - { - if (ch==entity->c) {xstrcpy(dest,entity->s); dest+=entity->l; source++; goto out_of_loop1; } - entity++; - } while(entity->s); -#ifdef _XMLWIDECHAR - *(dest++)=*(source++); -#else - switch(XML_ByteTable[(unsigned char)ch]) - { - case 4: - if ((!(source[1]))||(!(source[2]))||(!(source[3]))) { *(dest++)='_'; source++; } - else - { - *dest=*source; - dest[1]=source[1]; - dest[2]=source[2]; - dest[3]=source[3]; - dest+=4; source+=4; - } - break; - case 3: - if ((!(source[1]))||(!(source[2]))) { *(dest++)='_'; source++; } - else - { - *dest=*source; - dest[1]=source[1]; - dest[2]=source[2]; - dest+=3; source+=3; - } - break; - case 2: - if (!(source[1])) { *(dest++)='_'; source++; } - else - { - *dest=*source; - dest[1]=source[1]; - dest+=2; source+=2; - } - break; - case 1: *(dest++)=*(source++); - } -#endif -out_of_loop1: - ; - } - *dest=0; - return dd; -} - -// private (used while rendering): -int ToXMLStringTool::lengthXMLString(XMLCSTR source) -{ - int r=0; - XMLCharacterEntity *entity; - XMLCHAR ch; - while ((ch=*source)) - { - entity=XMLEntities; - do - { - if (ch==entity->c) { r+=entity->l; source++; goto out_of_loop1; } - entity++; - } while(entity->s); -#ifdef _XMLWIDECHAR - r++; source++; -#else - ch=XML_ByteTable[(unsigned char)ch]; r+=ch; source+=ch; -#endif -out_of_loop1: - ; - } - return r; -} - -ToXMLStringTool::~ToXMLStringTool(){ freeBuffer(); } -void ToXMLStringTool::freeBuffer(){ if (buf) free(buf); buf=NULL; buflen=0; } -XMLSTR ToXMLStringTool::toXML(XMLCSTR source) -{ - if (!source) - { - if (buflen<1) { buflen=1; buf=(XMLSTR)malloc(sizeof(XMLCHAR)); } - *buf=0; - return buf; - } - int l=lengthXMLString(source)+1; - if (l>buflen) { freeBuffer(); buflen=l; buf=(XMLSTR)malloc(l*sizeof(XMLCHAR)); } - return toXMLUnSafe(buf,source); -} - -// private: -XMLSTR fromXMLString(XMLCSTR s, int lo, XML *pXML) -{ - // This function is the opposite of the function "toXMLString". It decodes the escape - // sequences &, ", ', <, > and replace them by the characters - // &,",',<,>. This function is used internally by the XML Parser. All the calls to - // the XML library will always gives you back "decoded" strings. - // - // in: string (s) and length (lo) of string - // out: new allocated string converted from xml - if (!s) return NULL; - - int ll=0,j; - XMLSTR d; - XMLCSTR ss=s; - XMLCharacterEntity *entity; - while ((lo>0)&&(*s)) - { - if (*s==_CXML('&')) - { - if ((lo>2)&&(s[1]==_CXML('#'))) - { - s+=2; lo-=2; - if ((*s==_CXML('X'))||(*s==_CXML('x'))) { s++; lo--; } - while ((*s)&&(*s!=_CXML(';'))&&((lo--)>0)) s++; - if (*s!=_CXML(';')) - { - pXML->error=eXMLErrorUnknownCharacterEntity; - return NULL; - } - s++; lo--; - } else - { - entity=XMLEntities; - do - { - if ((lo>=entity->l)&&(xstrnicmp(s,entity->s,entity->l)==0)) { s+=entity->l; lo-=entity->l; break; } - entity++; - } while(entity->s); - if (!entity->s) - { - pXML->error=eXMLErrorUnknownCharacterEntity; - return NULL; - } - } - } else - { -#ifdef _XMLWIDECHAR - s++; lo--; -#else - j=XML_ByteTable[(unsigned char)*s]; s+=j; lo-=j; ll+=j-1; -#endif - } - ll++; - } - - d=(XMLSTR)malloc((ll+1)*sizeof(XMLCHAR)); - s=d; - while (ll-->0) - { - if (*ss==_CXML('&')) - { - if (ss[1]==_CXML('#')) - { - ss+=2; j=0; - if ((*ss==_CXML('X'))||(*ss==_CXML('x'))) - { - ss++; - while (*ss!=_CXML(';')) - { - if ((*ss>=_CXML('0'))&&(*ss<=_CXML('9'))) j=(j<<4)+*ss-_CXML('0'); - else if ((*ss>=_CXML('A'))&&(*ss<=_CXML('F'))) j=(j<<4)+*ss-_CXML('A')+10; - else if ((*ss>=_CXML('a'))&&(*ss<=_CXML('f'))) j=(j<<4)+*ss-_CXML('a')+10; - else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;} - ss++; - } - } else - { - while (*ss!=_CXML(';')) - { - if ((*ss>=_CXML('0'))&&(*ss<=_CXML('9'))) j=(j*10)+*ss-_CXML('0'); - else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;} - ss++; - } - } -#ifndef _XMLWIDECHAR - if (j>255) { free((void*)s); pXML->error=eXMLErrorCharacterCodeAbove255;return NULL;} -#endif - (*d++)=(XMLCHAR)j; ss++; - } else - { - entity=XMLEntities; - do - { - if (xstrnicmp(ss,entity->s,entity->l)==0) { *(d++)=entity->c; ss+=entity->l; break; } - entity++; - } while(entity->s); - } - } else - { -#ifdef _XMLWIDECHAR - *(d++)=*(ss++); -#else - switch(XML_ByteTable[(unsigned char)*ss]) - { - case 4: *(d++)=*(ss++); ll--; - case 3: *(d++)=*(ss++); ll--; - case 2: *(d++)=*(ss++); ll--; - case 1: *(d++)=*(ss++); - } -#endif - } - } - *d=0; - return (XMLSTR)s; -} - -#define XML_isSPACECHAR(ch) ((ch==_CXML('\n'))||(ch==_CXML(' '))||(ch== _CXML('\t'))||(ch==_CXML('\r'))) - -// private: -char myTagCompare(XMLCSTR cclose, XMLCSTR copen) -// !!!! WARNING strange convention&: -// return 0 if equals -// return 1 if different -{ - if (!cclose) return 1; - int l=(int)xstrlen(cclose); - if (xstrnicmp(cclose, copen, l)!=0) return 1; - const XMLCHAR c=copen[l]; - if (XML_isSPACECHAR(c)|| - (c==_CXML('/' ))|| - (c==_CXML('<' ))|| - (c==_CXML('>' ))|| - (c==_CXML('=' ))) return 0; - return 1; -} - -// Obtain the next character from the string. -static inline XMLCHAR getNextChar(XML *pXML) -{ - XMLCHAR ch = pXML->lpXML[pXML->nIndex]; -#ifdef _XMLWIDECHAR - if (ch!=0) pXML->nIndex++; -#else - pXML->nIndex+=XML_ByteTable[(unsigned char)ch]; -#endif - return ch; -} - -// Find the next token in a string. -// pcbToken contains the number of characters that have been read. -static NextToken GetNextToken(XML *pXML, int *pcbToken, enum XMLTokenTypeTag *pType) -{ - NextToken result; - XMLCHAR ch; - XMLCHAR chTemp; - int indexStart,nFoundMatch,nIsText=FALSE; - result.pClr=NULL; // prevent warning - - // Find next non-white space character - do { indexStart=pXML->nIndex; ch=getNextChar(pXML); } while XML_isSPACECHAR(ch); - - if (ch) - { - // Cache the current string pointer - result.pStr = &pXML->lpXML[indexStart]; - - // check for standard tokens - switch(ch) - { - // Check for quotes - case _CXML('\''): - case _CXML('\"'): - // Type of token - *pType = eTokenQuotedText; - chTemp = ch; - - // Set the size - nFoundMatch = FALSE; - - // Search through the string to find a matching quote - while((ch = getNextChar(pXML))) - { - if (ch==chTemp) { nFoundMatch = TRUE; break; } - if (ch==_CXML('<')) break; - } - - // If we failed to find a matching quote - if (nFoundMatch == FALSE) - { - pXML->nIndex=indexStart+1; - nIsText=TRUE; - break; - } - -// 4.02.2002 -// if (FindNonWhiteSpace(pXML)) pXML->nIndex--; - - break; - - // Equals (used with attribute values) - case _CXML('='): - *pType = eTokenEquals; - break; - - // Close tag - case _CXML('>'): - *pType = eTokenCloseTag; - break; - - // Check for tag start and tag end - case _CXML('<'): - - { - // First check whether the token is in the clear tag list (meaning it - // does not need formatting). - ALLXMLClearTag *ctag=XMLClearTags; - do - { - if (!xstrncmp(ctag->lpszOpen, result.pStr, ctag->openTagLen)) - { - result.pClr=ctag; - pXML->nIndex+=ctag->openTagLen-1; - *pType=eTokenClear; - return result; - } - ctag++; - } while(ctag->lpszOpen); - - // Peek at the next character to see if we have an end tag 'lpXML[pXML->nIndex]; - - // If we have a tag end... - if (chTemp == _CXML('/')) - { - // Set the type and ensure we point at the next character - getNextChar(pXML); - *pType = eTokenTagEnd; - } - - // If we have an XML declaration tag - else if (chTemp == _CXML('?')) - { - - // Set the type and ensure we point at the next character - getNextChar(pXML); - *pType = eTokenDeclaration; - } - - // Otherwise we must have a start tag - else - { - *pType = eTokenTagStart; - } - break; - } - - // Check to see if we have a short hand type end tag ('/>'). - case _CXML('/'): - - // Peek at the next character to see if we have a short end tag '/>' - chTemp = pXML->lpXML[pXML->nIndex]; - - // If we have a short hand end tag... - if (chTemp == _CXML('>')) - { - // Set the type and ensure we point at the next character - getNextChar(pXML); - *pType = eTokenShortHandClose; - break; - } - - // If we haven't found a short hand closing tag then drop into the - // text process - - // Other characters - default: - nIsText = TRUE; - } - - // If this is a TEXT node - if (nIsText) - { - // Indicate we are dealing with text - *pType = eTokenText; - while((ch = getNextChar(pXML))) - { - if XML_isSPACECHAR(ch) - { - indexStart++; break; - - } else if (ch==_CXML('/')) - { - // If we find a slash then this maybe text or a short hand end tag - // Peek at the next character to see it we have short hand end tag - ch=pXML->lpXML[pXML->nIndex]; - // If we found a short hand end tag then we need to exit the loop - if (ch==_CXML('>')) { pXML->nIndex--; break; } - - } else if ((ch==_CXML('<'))||(ch==_CXML('>'))||(ch==_CXML('='))) - { - pXML->nIndex--; break; - } - } - } - *pcbToken = pXML->nIndex-indexStart; - } else - { - // If we failed to obtain a valid character - *pcbToken = 0; - *pType = eTokenError; - result.pStr=NULL; - } - - return result; -} - -XMLCSTR XMLNode::updateName_WOSD(XMLSTR lpszName) -{ - if (!d) { free(lpszName); return NULL; } - if (d->lpszName&&(lpszName!=d->lpszName)) free((void*)d->lpszName); - d->lpszName=lpszName; - return lpszName; -} - -// private: -XMLNode::XMLNode(struct XMLNodeDataTag *p){ d=p; (p->ref_count)++; } -XMLNode::XMLNode(XMLNodeData *pParent, XMLSTR lpszName, char isDeclaration) -{ - d=(XMLNodeData*)malloc(sizeof(XMLNodeData)); - d->ref_count=1; - - d->lpszName=NULL; - d->nChild= 0; - d->nText = 0; - d->nClear = 0; - d->nAttribute = 0; - - d->isDeclaration = isDeclaration; - - d->pParent = pParent; - d->pChild= NULL; - d->pText= NULL; - d->pClear= NULL; - d->pAttribute= NULL; - d->pOrder= NULL; - - updateName_WOSD(lpszName); -} - -XMLNode XMLNode::createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration) { return XMLNode(NULL,lpszName,isDeclaration); } -XMLNode XMLNode::createXMLTopNode(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,stringDup(lpszName),isDeclaration); } - -#define MEMORYINCREASE 50 - -static inline void myFree(void *p) { if (p) free(p); } -static inline void *myRealloc(void *p, int newsize, int memInc, int sizeofElem) -{ - if (p==NULL) { if (memInc) return malloc(memInc*sizeofElem); return malloc(sizeofElem); } - if ((memInc==0)||((newsize%memInc)==0)) p=realloc(p,(newsize+memInc)*sizeofElem); -// if (!p) -// { -// printf("XMLParser Error: Not enough memory! Aborting...\n"); exit(220); -// } - return p; -} - -// private: -XMLElementPosition XMLNode::findPosition(XMLNodeData *d, int index, XMLElementType xxtype) -{ - if (index<0) return -1; - int i=0,j=(int)((index<<2)+xxtype),*o=d->pOrder; while (o[i]!=j) i++; return i; -} - -// private: -// update "order" information when deleting a content of a XMLNode -int XMLNode::removeOrderElement(XMLNodeData *d, XMLElementType t, int index) -{ - int n=d->nChild+d->nText+d->nClear, *o=d->pOrder,i=findPosition(d,index,t); - memmove(o+i, o+i+1, (n-i)*sizeof(int)); - for (;ipOrder=(int)realloc(d->pOrder,n*sizeof(int)); - // but we skip reallocation because it's too time consuming. - // Anyway, at the end, it will be free'd completely at once. - return i; -} - -void *XMLNode::addToOrder(int memoryIncrease,int *_pos, int nc, void *p, int size, XMLElementType xtype) -{ - // in: *_pos is the position inside d->pOrder ("-1" means "EndOf") - // out: *_pos is the index inside p - p=myRealloc(p,(nc+1),memoryIncrease,size); - int n=d->nChild+d->nText+d->nClear; - d->pOrder=(int*)myRealloc(d->pOrder,n+1,memoryIncrease*3,sizeof(int)); - int pos=*_pos,*o=d->pOrder; - - if ((pos<0)||(pos>=n)) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; } - - int i=pos; - memmove(o+i+1, o+i, (n-i)*sizeof(int)); - - while ((pos>2; - memmove(((char*)p)+(pos+1)*size,((char*)p)+pos*size,(nc-pos)*size); - - return p; -} - -// Add a child node to the given element. -XMLNode XMLNode::addChild_priv(int memoryIncrease, XMLSTR lpszName, char isDeclaration, int pos) -{ - if (!lpszName) return emptyXMLNode; - d->pChild=(XMLNode*)addToOrder(memoryIncrease,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild); - d->pChild[pos].d=NULL; - d->pChild[pos]=XMLNode(d,lpszName,isDeclaration); - d->nChild++; - return d->pChild[pos]; -} - -// Add an attribute to an element. -XMLAttribute *XMLNode::addAttribute_priv(int memoryIncrease,XMLSTR lpszName, XMLSTR lpszValuev) -{ - if (!lpszName) return &emptyXMLAttribute; - if (!d) { myFree(lpszName); myFree(lpszValuev); return &emptyXMLAttribute; } - int nc=d->nAttribute; - d->pAttribute=(XMLAttribute*)myRealloc(d->pAttribute,(nc+1),memoryIncrease,sizeof(XMLAttribute)); - XMLAttribute *pAttr=d->pAttribute+nc; - pAttr->lpszName = lpszName; - pAttr->lpszValue = lpszValuev; - d->nAttribute++; - return pAttr; -} - -// Add text to the element. -XMLCSTR XMLNode::addText_priv(int memoryIncrease, XMLSTR lpszValue, int pos) -{ - if (!lpszValue) return NULL; - if (!d) { myFree(lpszValue); return NULL; } - d->pText=(XMLCSTR*)addToOrder(memoryIncrease,&pos,d->nText,d->pText,sizeof(XMLSTR),eNodeText); - d->pText[pos]=lpszValue; - d->nText++; - return lpszValue; -} - -// Add clear (unformatted) text to the element. -XMLClear *XMLNode::addClear_priv(int memoryIncrease, XMLSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos) -{ - if (!lpszValue) return &emptyXMLClear; - if (!d) { myFree(lpszValue); return &emptyXMLClear; } - d->pClear=(XMLClear *)addToOrder(memoryIncrease,&pos,d->nClear,d->pClear,sizeof(XMLClear),eNodeClear); - XMLClear *pNewClear=d->pClear+pos; - pNewClear->lpszValue = lpszValue; - if (!lpszOpen) lpszOpen=XMLClearTags->lpszOpen; - if (!lpszClose) lpszClose=XMLClearTags->lpszClose; - pNewClear->lpszOpenTag = lpszOpen; - pNewClear->lpszCloseTag = lpszClose; - d->nClear++; - return pNewClear; -} - -// private: -// Parse a clear (unformatted) type node. -char XMLNode::parseClearTag(void *px, void *_pClear) -{ - XML *pXML=(XML *)px; - ALLXMLClearTag pClear=*((ALLXMLClearTag*)_pClear); - int cbTemp=0; - XMLCSTR lpszTemp=NULL; - XMLCSTR lpXML=&pXML->lpXML[pXML->nIndex]; - static XMLCSTR docTypeEnd=_CXML("]>"); - - // Find the closing tag - // Seems the ')) { lpszTemp=pCh; break; } -#ifdef _XMLWIDECHAR - pCh++; -#else - pCh+=XML_ByteTable[(unsigned char)(*pCh)]; -#endif - } - } else lpszTemp=xstrstr(lpXML, pClear.lpszClose); - - if (lpszTemp) - { - // Cache the size and increment the index - cbTemp = (int)(lpszTemp - lpXML); - - pXML->nIndex += cbTemp+(int)xstrlen(pClear.lpszClose); - - // Add the clear node to the current element - addClear_priv(MEMORYINCREASE,cbTemp?stringDup(lpXML,cbTemp):NULL, pClear.lpszOpen, pClear.lpszClose,-1); - return 0; - } - - // If we failed to find the end tag - pXML->error = eXMLErrorUnmatchedEndClearTag; - return 1; -} - -void XMLNode::exactMemory(XMLNodeData *d) -{ - if (d->pOrder) d->pOrder=(int*)realloc(d->pOrder,(d->nChild+d->nText+d->nClear)*sizeof(int)); - if (d->pChild) d->pChild=(XMLNode*)realloc(d->pChild,d->nChild*sizeof(XMLNode)); - if (d->pAttribute) d->pAttribute=(XMLAttribute*)realloc(d->pAttribute,d->nAttribute*sizeof(XMLAttribute)); - if (d->pText) d->pText=(XMLCSTR*)realloc(d->pText,d->nText*sizeof(XMLSTR)); - if (d->pClear) d->pClear=(XMLClear *)realloc(d->pClear,d->nClear*sizeof(XMLClear)); -} - -char XMLNode::maybeAddTxT(void *pa, XMLCSTR tokenPStr) -{ - XML *pXML=(XML *)pa; - XMLCSTR lpszText=pXML->lpszText; - if (!lpszText) return 0; - if (dropWhiteSpace) while (XML_isSPACECHAR(*lpszText)&&(lpszText!=tokenPStr)) lpszText++; - int cbText = (int)(tokenPStr - lpszText); - if (!cbText) { pXML->lpszText=NULL; return 0; } - if (dropWhiteSpace) { cbText--; while ((cbText)&&XML_isSPACECHAR(lpszText[cbText])) cbText--; cbText++; } - if (!cbText) { pXML->lpszText=NULL; return 0; } - XMLSTR lpt=fromXMLString(lpszText,cbText,pXML); - if (!lpt) return 1; - pXML->lpszText=NULL; - if (removeCommentsInMiddleOfText && d->nText && d->nClear) - { - // if the previous insertion was a comment () AND - // if the previous previous insertion was a text then, delete the comment and append the text - int n=d->nChild+d->nText+d->nClear-1,*o=d->pOrder; - if (((o[n]&3)==eNodeClear)&&((o[n-1]&3)==eNodeText)) - { - int i=o[n]>>2; - if (d->pClear[i].lpszOpenTag==XMLClearTags[2].lpszOpen) - { - deleteClear(i); - i=o[n-1]>>2; - n=xstrlen(d->pText[i]); - int n2=xstrlen(lpt)+1; - d->pText[i]=(XMLSTR)realloc((void*)d->pText[i],(n+n2)*sizeof(XMLCHAR)); - if (!d->pText[i]) return 1; - memcpy((void*)(d->pText[i]+n),lpt,n2*sizeof(XMLCHAR)); - free(lpt); - return 0; - } - } - } - addText_priv(MEMORYINCREASE,lpt,-1); - return 0; -} -// private: -// Recursively parse an XML element. -int XMLNode::ParseXMLElement(void *pa) -{ - XML *pXML=(XML *)pa; - int cbToken; - enum XMLTokenTypeTag xtype; - NextToken token; - XMLCSTR lpszTemp=NULL; - int cbTemp=0; - char nDeclaration; - XMLNode pNew; - enum XMLStatus status; // inside or outside a tag - enum Attrib attrib = eAttribName; - - assert(pXML); - - // If this is the first call to the function - if (pXML->nFirst) - { - // Assume we are outside of a tag definition - pXML->nFirst = FALSE; - status = eOutsideTag; - } else - { - // If this is not the first call then we should only be called when inside a tag. - status = eInsideTag; - } - - // Iterate through the tokens in the document - for(;;) - { - // Obtain the next token - token = GetNextToken(pXML, &cbToken, &xtype); - - if (xtype != eTokenError) - { - // Check the current status - switch(status) - { - - // If we are outside of a tag definition - case eOutsideTag: - - // Check what type of token we obtained - switch(xtype) - { - // If we have found text or quoted text - case eTokenText: - case eTokenCloseTag: /* '>' */ - case eTokenShortHandClose: /* '/>' */ - case eTokenQuotedText: - case eTokenEquals: - break; - - // If we found a start tag '<' and declarations 'error = eXMLErrorMissingTagName; - return FALSE; - } - - // If we found a new element which is the same as this - // element then we need to pass this back to the caller.. - -#ifdef APPROXIMATE_PARSING - if (d->lpszName && - myTagCompare(d->lpszName, token.pStr) == 0) - { - // Indicate to the caller that it needs to create a - // new element. - pXML->lpNewElement = token.pStr; - pXML->cbNewElement = cbToken; - return TRUE; - } else -#endif - { - // If the name of the new element differs from the name of - // the current element we need to add the new element to - // the current one and recurse - pNew = addChild_priv(MEMORYINCREASE,stringDup(token.pStr,cbToken), nDeclaration,-1); - - while (!pNew.isEmpty()) - { - // Callself to process the new node. If we return - // FALSE this means we dont have any more - // processing to do... - - if (!pNew.ParseXMLElement(pXML)) return FALSE; - else - { - // If the call to recurse this function - // evented in a end tag specified in XML then - // we need to unwind the calls to this - // function until we find the appropriate node - // (the element name and end tag name must - // match) - if (pXML->cbEndTag) - { - // If we are back at the root node then we - // have an unmatched end tag - if (!d->lpszName) - { - pXML->error=eXMLErrorUnmatchedEndTag; - return FALSE; - } - - // If the end tag matches the name of this - // element then we only need to unwind - // once more... - - if (myTagCompare(d->lpszName, pXML->lpEndTag)==0) - { - pXML->cbEndTag = 0; - } - - return TRUE; - } else - if (pXML->cbNewElement) - { - // If the call indicated a new element is to - // be created on THIS element. - - // If the name of this element matches the - // name of the element we need to create - // then we need to return to the caller - // and let it process the element. - - if (myTagCompare(d->lpszName, pXML->lpNewElement)==0) - { - return TRUE; - } - - // Add the new element and recurse - pNew = addChild_priv(MEMORYINCREASE,stringDup(pXML->lpNewElement,pXML->cbNewElement),0,-1); - pXML->cbNewElement = 0; - } - else - { - // If we didn't have a new element to create - pNew = emptyXMLNode; - - } - } - } - } - break; - - // If we found an end tag - case eTokenTagEnd: - - // If we have node text then add this to the element - if (maybeAddTxT(pXML,token.pStr)) return FALSE; - - // Find the name of the end tag - token = GetNextToken(pXML, &cbTemp, &xtype); - - // The end tag should be text - if (xtype != eTokenText) - { - pXML->error = eXMLErrorMissingEndTagName; - return FALSE; - } - lpszTemp = token.pStr; - - // After the end tag we should find a closing tag - token = GetNextToken(pXML, &cbToken, &xtype); - if (xtype != eTokenCloseTag) - { - pXML->error = eXMLErrorMissingEndTagName; - return FALSE; - } - pXML->lpszText=pXML->lpXML+pXML->nIndex; - - // We need to return to the previous caller. If the name - // of the tag cannot be found we need to keep returning to - // caller until we find a match - if (myTagCompare(d->lpszName, lpszTemp) != 0) -#ifdef STRICT_PARSING - { - pXML->error=eXMLErrorUnmatchedEndTag; - pXML->nIndexMissigEndTag=pXML->nIndex; - return FALSE; - } -#else - { - pXML->error=eXMLErrorMissingEndTag; - pXML->nIndexMissigEndTag=pXML->nIndex; - pXML->lpEndTag = lpszTemp; - pXML->cbEndTag = cbTemp; - } -#endif - - // Return to the caller - exactMemory(d); - return TRUE; - - // If we found a clear (unformatted) token - case eTokenClear: - // If we have node text then add this to the element - if (maybeAddTxT(pXML,token.pStr)) return FALSE; - if (parseClearTag(pXML, token.pClr)) return FALSE; - pXML->lpszText=pXML->lpXML+pXML->nIndex; - break; - - default: - break; - } - break; - - // If we are inside a tag definition we need to search for attributes - case eInsideTag: - - // Check what part of the attribute (name, equals, value) we - // are looking for. - switch(attrib) - { - // If we are looking for a new attribute - case eAttribName: - - // Check what the current token type is - switch(xtype) - { - // If the current type is text... - // Eg. 'attribute' - case eTokenText: - // Cache the token then indicate that we are next to - // look for the equals - lpszTemp = token.pStr; - cbTemp = cbToken; - attrib = eAttribEquals; - break; - - // If we found a closing tag... - // Eg. '>' - case eTokenCloseTag: - // We are now outside the tag - status = eOutsideTag; - pXML->lpszText=pXML->lpXML+pXML->nIndex; - break; - - // If we found a short hand '/>' closing tag then we can - // return to the caller - case eTokenShortHandClose: - exactMemory(d); - pXML->lpszText=pXML->lpXML+pXML->nIndex; - return TRUE; - - // Errors... - case eTokenQuotedText: /* '"SomeText"' */ - case eTokenTagStart: /* '<' */ - case eTokenTagEnd: /* 'error = eXMLErrorUnexpectedToken; - return FALSE; - default: break; - } - break; - - // If we are looking for an equals - case eAttribEquals: - // Check what the current token type is - switch(xtype) - { - // If the current type is text... - // Eg. 'Attribute AnotherAttribute' - case eTokenText: - // Add the unvalued attribute to the list - addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp), NULL); - // Cache the token then indicate. We are next to - // look for the equals attribute - lpszTemp = token.pStr; - cbTemp = cbToken; - break; - - // If we found a closing tag 'Attribute >' or a short hand - // closing tag 'Attribute />' - case eTokenShortHandClose: - case eTokenCloseTag: - // If we are a declaration element 'lpszText=pXML->lpXML+pXML->nIndex; - - if (d->isDeclaration && - (lpszTemp[cbTemp-1]) == _CXML('?')) - { - cbTemp--; - if (d->pParent && d->pParent->pParent) xtype = eTokenShortHandClose; - } - - if (cbTemp) - { - // Add the unvalued attribute to the list - addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp), NULL); - } - - // If this is the end of the tag then return to the caller - if (xtype == eTokenShortHandClose) - { - exactMemory(d); - return TRUE; - } - - // We are now outside the tag - status = eOutsideTag; - break; - - // If we found the equals token... - // Eg. 'Attribute =' - case eTokenEquals: - // Indicate that we next need to search for the value - // for the attribute - attrib = eAttribValue; - break; - - // Errors... - case eTokenQuotedText: /* 'Attribute "InvalidAttr"'*/ - case eTokenTagStart: /* 'Attribute <' */ - case eTokenTagEnd: /* 'Attribute error = eXMLErrorUnexpectedToken; - return FALSE; - default: break; - } - break; - - // If we are looking for an attribute value - case eAttribValue: - // Check what the current token type is - switch(xtype) - { - // If the current type is text or quoted text... - // Eg. 'Attribute = "Value"' or 'Attribute = Value' or - // 'Attribute = 'Value''. - case eTokenText: - case eTokenQuotedText: - // If we are a declaration element 'isDeclaration && - (token.pStr[cbToken-1]) == _CXML('?')) - { - cbToken--; - } - - if (cbTemp) - { - // Add the valued attribute to the list - if (xtype==eTokenQuotedText) { token.pStr++; cbToken-=2; } - XMLSTR attrVal=(XMLSTR)token.pStr; - if (attrVal) - { - attrVal=fromXMLString(attrVal,cbToken,pXML); - if (!attrVal) return FALSE; - } - addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp),attrVal); - } - - // Indicate we are searching for a new attribute - attrib = eAttribName; - break; - - // Errors... - case eTokenTagStart: /* 'Attr = <' */ - case eTokenTagEnd: /* 'Attr = ' */ - case eTokenShortHandClose: /* "Attr = />" */ - case eTokenEquals: /* 'Attr = =' */ - case eTokenDeclaration: /* 'Attr = error = eXMLErrorUnexpectedToken; - return FALSE; - break; - default: break; - } - } - } - } - // If we failed to obtain the next token - else - { - if ((!d->isDeclaration)&&(d->pParent)) - { -#ifdef STRICT_PARSING - pXML->error=eXMLErrorUnmatchedEndTag; -#else - pXML->error=eXMLErrorMissingEndTag; -#endif - pXML->nIndexMissigEndTag=pXML->nIndex; - } - maybeAddTxT(pXML,pXML->lpXML+pXML->nIndex); - return FALSE; - } - } -} - -// Count the number of lines and columns in an XML string. -static void CountLinesAndColumns(XMLCSTR lpXML, int nUpto, XMLResults *pResults) -{ - XMLCHAR ch; - assert(lpXML); - assert(pResults); - - struct XML xml={ lpXML,lpXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE }; - - pResults->nLine = 1; - pResults->nColumn = 1; - while (xml.nIndexnColumn++; - else - { - pResults->nLine++; - pResults->nColumn=1; - } - } -} - -// Parse XML and return the root element. -XMLNode XMLNode::parseString(XMLCSTR lpszXML, XMLCSTR tag, XMLResults *pResults) -{ - if (!lpszXML) - { - if (pResults) - { - pResults->error=eXMLErrorNoElements; - pResults->nLine=0; - pResults->nColumn=0; - } - return emptyXMLNode; - } - - XMLNode xnode(NULL,NULL,FALSE); - struct XML xml={ lpszXML, lpszXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE }; - - // Create header element - xnode.ParseXMLElement(&xml); - enum XMLError error = xml.error; - if (!xnode.nChildNode()) error=eXMLErrorNoXMLTagFound; - if ((xnode.nChildNode()==1)&&(xnode.nElement()==1)) xnode=xnode.getChildNode(); // skip the empty node - - // If no error occurred - if ((error==eXMLErrorNone)||(error==eXMLErrorMissingEndTag)||(error==eXMLErrorNoXMLTagFound)) - { - XMLCSTR name=xnode.getName(); - if (tag&&(*tag)&&((!name)||(xstricmp(name,tag)))) - { - xnode=xnode.getChildNode(tag); - if (xnode.isEmpty()) - { - if (pResults) - { - pResults->error=eXMLErrorFirstTagNotFound; - pResults->nLine=0; - pResults->nColumn=0; - } - return emptyXMLNode; - } - } - } else - { - // Cleanup: this will destroy all the nodes - xnode = emptyXMLNode; - } - - - // If we have been given somewhere to place results - if (pResults) - { - pResults->error = error; - - // If we have an error - if (error!=eXMLErrorNone) - { - if (error==eXMLErrorMissingEndTag) xml.nIndex=xml.nIndexMissigEndTag; - // Find which line and column it starts on. - CountLinesAndColumns(xml.lpXML, xml.nIndex, pResults); - } - } - return xnode; -} - -XMLNode XMLNode::parseFile(XMLCSTR filename, XMLCSTR tag, XMLResults *pResults) -{ - if (pResults) { pResults->nLine=0; pResults->nColumn=0; } - FILE *f=xfopen(filename,_CXML("rb")); - if (f==NULL) { if (pResults) pResults->error=eXMLErrorFileNotFound; return emptyXMLNode; } - fseek(f,0,SEEK_END); - int l=(int)ftell(f),headerSz=0; - if (!l) { if (pResults) pResults->error=eXMLErrorEmpty; fclose(f); return emptyXMLNode; } - fseek(f,0,SEEK_SET); - unsigned char *buf=(unsigned char*)malloc(l+4); - l=(int)fread(buf,1,l,f); - fclose(f); - buf[l]=0;buf[l+1]=0;buf[l+2]=0;buf[l+3]=0; -#ifdef _XMLWIDECHAR - if (guessWideCharChars) - { - if (!myIsTextWideChar(buf,l)) - { - XMLNode::XMLCharEncoding ce=XMLNode::char_encoding_legacy; - if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) { headerSz=3; ce=XMLNode::char_encoding_UTF8; } - XMLSTR b2=myMultiByteToWideChar((const char*)(buf+headerSz),ce); - if (!b2) - { - // todo: unable to convert - } - free(buf); buf=(unsigned char*)b2; headerSz=0; - } else - { - if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2; - if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2; - } - } else - { - if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2; - if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2; - if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3; - } -#else - if (guessWideCharChars) - { - if (myIsTextWideChar(buf,l)) - { - if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2; - if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2; - char *b2=myWideCharToMultiByte((const wchar_t*)(buf+headerSz)); - free(buf); buf=(unsigned char*)b2; headerSz=0; - } else - { - if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3; - } - } else - { - if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2; - if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2; - if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3; - } -#endif - - if (!buf) { if (pResults) pResults->error=eXMLErrorCharConversionError; return emptyXMLNode; } - XMLNode x=parseString((XMLSTR)(buf+headerSz),tag,pResults); - free(buf); - return x; -} - -static inline void charmemset(XMLSTR dest,XMLCHAR c,int l) { while (l--) *(dest++)=c; } -// private: -// Creates an user friendly XML string from a given element with -// appropriate white space and carriage returns. -// -// This recurses through all subnodes then adds contents of the nodes to the -// string. -int XMLNode::CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat) -{ - int nResult = 0; - int cb=nFormat<0?0:nFormat; - int cbElement; - int nChildFormat=-1; - int nElementI=pEntry->nChild+pEntry->nText+pEntry->nClear; - int i,j; - if ((nFormat>=0)&&(nElementI==1)&&(pEntry->nText==1)&&(!pEntry->isDeclaration)) nFormat=-2; - - assert(pEntry); - -#define LENSTR(lpsz) (lpsz ? xstrlen(lpsz) : 0) - - // If the element has no name then assume this is the head node. - cbElement = (int)LENSTR(pEntry->lpszName); - - if (cbElement) - { - // "isDeclaration) lpszMarker[nResult++]=_CXML('?'); - xstrcpy(&lpszMarker[nResult], pEntry->lpszName); - nResult+=cbElement; - lpszMarker[nResult++]=_CXML(' '); - - } else - { - nResult+=cbElement+2+cb; - if (pEntry->isDeclaration) nResult++; - } - - // Enumerate attributes and add them to the string - XMLAttribute *pAttr=pEntry->pAttribute; - for (i=0; inAttribute; i++) - { - // "Attrib - cb = (int)LENSTR(pAttr->lpszName); - if (cb) - { - if (lpszMarker) xstrcpy(&lpszMarker[nResult], pAttr->lpszName); - nResult += cb; - // "Attrib=Value " - if (pAttr->lpszValue) - { - cb=(int)ToXMLStringTool::lengthXMLString(pAttr->lpszValue); - if (lpszMarker) - { - lpszMarker[nResult]=_CXML('='); - lpszMarker[nResult+1]=_CXML('"'); - if (cb) ToXMLStringTool::toXMLUnSafe(&lpszMarker[nResult+2],pAttr->lpszValue); - lpszMarker[nResult+cb+2]=_CXML('"'); - } - nResult+=cb+3; - } - if (lpszMarker) lpszMarker[nResult] = _CXML(' '); - nResult++; - } - pAttr++; - } - - if (pEntry->isDeclaration) - { - if (lpszMarker) - { - lpszMarker[nResult-1]=_CXML('?'); - lpszMarker[nResult]=_CXML('>'); - } - nResult++; - if (nFormat!=-1) - { - if (lpszMarker) lpszMarker[nResult]=_CXML('\n'); - nResult++; - } - } else - // If there are child nodes we need to terminate the start tag - if (nElementI) - { - if (lpszMarker) lpszMarker[nResult-1]=_CXML('>'); - if (nFormat>=0) - { - if (lpszMarker) lpszMarker[nResult]=_CXML('\n'); - nResult++; - } - } else nResult--; - } - - // Calculate the child format for when we recurse. This is used to - // determine the number of spaces used for prefixes. - if (nFormat!=-1) - { - if (cbElement&&(!pEntry->isDeclaration)) nChildFormat=nFormat+1; - else nChildFormat=nFormat; - } - - // Enumerate through remaining children - for (i=0; ipOrder[i]; - switch((XMLElementType)(j&3)) - { - // Text nodes - case eNodeText: - { - // "Text" - XMLCSTR pChild=pEntry->pText[j>>2]; - cb = (int)ToXMLStringTool::lengthXMLString(pChild); - if (cb) - { - if (nFormat>=0) - { - if (lpszMarker) - { - charmemset(&lpszMarker[nResult],INDENTCHAR,nFormat+1); - ToXMLStringTool::toXMLUnSafe(&lpszMarker[nResult+nFormat+1],pChild); - lpszMarker[nResult+nFormat+1+cb]=_CXML('\n'); - } - nResult+=cb+nFormat+2; - } else - { - if (lpszMarker) ToXMLStringTool::toXMLUnSafe(&lpszMarker[nResult], pChild); - nResult += cb; - } - } - break; - } - - // Clear type nodes - case eNodeClear: - { - XMLClear *pChild=pEntry->pClear+(j>>2); - // "OpenTag" - cb = (int)LENSTR(pChild->lpszOpenTag); - if (cb) - { - if (nFormat!=-1) - { - if (lpszMarker) - { - charmemset(&lpszMarker[nResult], INDENTCHAR, nFormat+1); - xstrcpy(&lpszMarker[nResult+nFormat+1], pChild->lpszOpenTag); - } - nResult+=cb+nFormat+1; - } - else - { - if (lpszMarker)xstrcpy(&lpszMarker[nResult], pChild->lpszOpenTag); - nResult += cb; - } - } - - // "OpenTag Value" - cb = (int)LENSTR(pChild->lpszValue); - if (cb) - { - if (lpszMarker) xstrcpy(&lpszMarker[nResult], pChild->lpszValue); - nResult += cb; - } - - // "OpenTag Value CloseTag" - cb = (int)LENSTR(pChild->lpszCloseTag); - if (cb) - { - if (lpszMarker) xstrcpy(&lpszMarker[nResult], pChild->lpszCloseTag); - nResult += cb; - } - - if (nFormat!=-1) - { - if (lpszMarker) lpszMarker[nResult] = _CXML('\n'); - nResult++; - } - break; - } - - // Element nodes - case eNodeChild: - { - // Recursively add child nodes - nResult += CreateXMLStringR(pEntry->pChild[j>>2].d, lpszMarker ? lpszMarker + nResult : 0, nChildFormat); - break; - } - default: break; - } - } - - if ((cbElement)&&(!pEntry->isDeclaration)) - { - // If we have child entries we need to use long XML notation for - // closing the element - "blah blah blah" - if (nElementI) - { - // "\0" - if (lpszMarker) - { - if (nFormat >=0) - { - charmemset(&lpszMarker[nResult], INDENTCHAR,nFormat); - nResult+=nFormat; - } - - lpszMarker[nResult]=_CXML('<'); lpszMarker[nResult+1]=_CXML('/'); - nResult += 2; - xstrcpy(&lpszMarker[nResult], pEntry->lpszName); - nResult += cbElement; - - lpszMarker[nResult]=_CXML('>'); - if (nFormat == -1) nResult++; - else - { - lpszMarker[nResult+1]=_CXML('\n'); - nResult+=2; - } - } else - { - if (nFormat>=0) nResult+=cbElement+4+nFormat; - else if (nFormat==-1) nResult+=cbElement+3; - else nResult+=cbElement+4; - } - } else - { - // If there are no children we can use shorthand XML notation - - // "" - // "/>\0" - if (lpszMarker) - { - lpszMarker[nResult]=_CXML('/'); lpszMarker[nResult+1]=_CXML('>'); - if (nFormat != -1) lpszMarker[nResult+2]=_CXML('\n'); - } - nResult += nFormat == -1 ? 2 : 3; - } - } - - return nResult; -} - -#undef LENSTR - -// Create an XML string -// @param int nFormat - 0 if no formatting is required -// otherwise nonzero for formatted text -// with carriage returns and indentation. -// @param int *pnSize - [out] pointer to the size of the -// returned string not including the -// NULL terminator. -// @return XMLSTR - Allocated XML string, you must free -// this with free(). -XMLSTR XMLNode::createXMLString(int nFormat, int *pnSize) const -{ - if (!d) { if (pnSize) *pnSize=0; return NULL; } - - XMLSTR lpszResult = NULL; - int cbStr; - - // Recursively Calculate the size of the XML string - if (!dropWhiteSpace) nFormat=0; - nFormat = nFormat ? 0 : -1; - cbStr = CreateXMLStringR(d, 0, nFormat); - // Alllocate memory for the XML string + the NULL terminator and - // create the recursively XML string. - lpszResult=(XMLSTR)malloc((cbStr+1)*sizeof(XMLCHAR)); - CreateXMLStringR(d, lpszResult, nFormat); - lpszResult[cbStr]=_CXML('\0'); - if (pnSize) *pnSize = cbStr; - return lpszResult; -} - -int XMLNode::detachFromParent(XMLNodeData *d) -{ - XMLNode *pa=d->pParent->pChild; - int i=0; - while (((void*)(pa[i].d))!=((void*)d)) i++; - d->pParent->nChild--; - if (d->pParent->nChild) memmove(pa+i,pa+i+1,(d->pParent->nChild-i)*sizeof(XMLNode)); - else { free(pa); d->pParent->pChild=NULL; } - return removeOrderElement(d->pParent,eNodeChild,i); -} - -XMLNode::~XMLNode() -{ - if (!d) return; - d->ref_count--; - emptyTheNode(0); -} -void XMLNode::deleteNodeContent() -{ - if (!d) return; - if (d->pParent) { detachFromParent(d); d->pParent=NULL; d->ref_count--; } - emptyTheNode(1); -} -void XMLNode::emptyTheNode(char force) -{ - XMLNodeData *dd=d; // warning: must stay this way! - if ((dd->ref_count==0)||force) - { - if (d->pParent) detachFromParent(d); - int i; - XMLNode *pc; - for(i=0; inChild; i++) - { - pc=dd->pChild+i; - pc->d->pParent=NULL; - pc->d->ref_count--; - pc->emptyTheNode(force); - } - myFree(dd->pChild); - for(i=0; inText; i++) free((void*)dd->pText[i]); - myFree(dd->pText); - for(i=0; inClear; i++) free((void*)dd->pClear[i].lpszValue); - myFree(dd->pClear); - for(i=0; inAttribute; i++) - { - free((void*)dd->pAttribute[i].lpszName); - if (dd->pAttribute[i].lpszValue) free((void*)dd->pAttribute[i].lpszValue); - } - myFree(dd->pAttribute); - myFree(dd->pOrder); - myFree((void*)dd->lpszName); - dd->nChild=0; dd->nText=0; dd->nClear=0; dd->nAttribute=0; - dd->pChild=NULL; dd->pText=NULL; dd->pClear=NULL; dd->pAttribute=NULL; - dd->pOrder=NULL; dd->lpszName=NULL; dd->pParent=NULL; - } - if (dd->ref_count==0) - { - free(dd); - d=NULL; - } -} - -XMLNode& XMLNode::operator=( const XMLNode& A ) -{ - // shallow copy - if (this != &A) - { - if (d) { d->ref_count--; emptyTheNode(0); } - d=A.d; - if (d) (d->ref_count) ++ ; - } - return *this; -} - -XMLNode::XMLNode(const XMLNode &A) -{ - // shallow copy - d=A.d; - if (d) (d->ref_count)++ ; -} - -XMLNode XMLNode::deepCopy() const -{ - if (!d) return XMLNode::emptyXMLNode; - XMLNode x(NULL,stringDup(d->lpszName),d->isDeclaration); - XMLNodeData *p=x.d; - int n=d->nAttribute; - if (n) - { - p->nAttribute=n; p->pAttribute=(XMLAttribute*)malloc(n*sizeof(XMLAttribute)); - while (n--) - { - p->pAttribute[n].lpszName=stringDup(d->pAttribute[n].lpszName); - p->pAttribute[n].lpszValue=stringDup(d->pAttribute[n].lpszValue); - } - } - if (d->pOrder) - { - n=(d->nChild+d->nText+d->nClear)*sizeof(int); p->pOrder=(int*)malloc(n); memcpy(p->pOrder,d->pOrder,n); - } - n=d->nText; - if (n) - { - p->nText=n; p->pText=(XMLCSTR*)malloc(n*sizeof(XMLCSTR)); - while(n--) p->pText[n]=stringDup(d->pText[n]); - } - n=d->nClear; - if (n) - { - p->nClear=n; p->pClear=(XMLClear*)malloc(n*sizeof(XMLClear)); - while (n--) - { - p->pClear[n].lpszCloseTag=d->pClear[n].lpszCloseTag; - p->pClear[n].lpszOpenTag=d->pClear[n].lpszOpenTag; - p->pClear[n].lpszValue=stringDup(d->pClear[n].lpszValue); - } - } - n=d->nChild; - if (n) - { - p->nChild=n; p->pChild=(XMLNode*)malloc(n*sizeof(XMLNode)); - while (n--) - { - p->pChild[n].d=NULL; - p->pChild[n]=d->pChild[n].deepCopy(); - p->pChild[n].d->pParent=p; - } - } - return x; -} - -XMLNode XMLNode::addChild(XMLNode childNode, int pos) -{ - XMLNodeData *dc=childNode.d; - if ((!dc)||(!d)) return childNode; - if (!dc->lpszName) - { - // this is a root node: todo: correct fix - int j=pos; - while (dc->nChild) - { - addChild(dc->pChild[0],j); - if (pos>=0) j++; - } - return childNode; - } - if (dc->pParent) { if ((detachFromParent(dc)<=pos)&&(dc->pParent==d)) pos--; } else dc->ref_count++; - dc->pParent=d; -// int nc=d->nChild; -// d->pChild=(XMLNode*)myRealloc(d->pChild,(nc+1),memoryIncrease,sizeof(XMLNode)); - d->pChild=(XMLNode*)addToOrder(0,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild); - d->pChild[pos].d=dc; - d->nChild++; - return childNode; -} - -void XMLNode::deleteAttribute(int i) -{ - if ((!d)||(i<0)||(i>=d->nAttribute)) return; - d->nAttribute--; - XMLAttribute *p=d->pAttribute+i; - free((void*)p->lpszName); - if (p->lpszValue) free((void*)p->lpszValue); - if (d->nAttribute) memmove(p,p+1,(d->nAttribute-i)*sizeof(XMLAttribute)); else { free(p); d->pAttribute=NULL; } -} - -void XMLNode::deleteAttribute(XMLAttribute *a){ if (a) deleteAttribute(a->lpszName); } -void XMLNode::deleteAttribute(XMLCSTR lpszName) -{ - int j=0; - getAttribute(lpszName,&j); - if (j) deleteAttribute(j-1); -} - -XMLAttribute *XMLNode::updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName,int i) -{ - if (!d) { if (lpszNewValue) free(lpszNewValue); if (lpszNewName) free(lpszNewName); return NULL; } - if (i>=d->nAttribute) - { - if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue); - return NULL; - } - XMLAttribute *p=d->pAttribute+i; - if (p->lpszValue&&p->lpszValue!=lpszNewValue) free((void*)p->lpszValue); - p->lpszValue=lpszNewValue; - if (lpszNewName&&p->lpszName!=lpszNewName) { free((void*)p->lpszName); p->lpszName=lpszNewName; }; - return p; -} - -XMLAttribute *XMLNode::updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute) -{ - if (oldAttribute) return updateAttribute_WOSD((XMLSTR)newAttribute->lpszValue,(XMLSTR)newAttribute->lpszName,oldAttribute->lpszName); - return addAttribute_WOSD((XMLSTR)newAttribute->lpszName,(XMLSTR)newAttribute->lpszValue); -} - -XMLAttribute *XMLNode::updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName,XMLCSTR lpszOldName) -{ - int j=0; - getAttribute(lpszOldName,&j); - if (j) return updateAttribute_WOSD(lpszNewValue,lpszNewName,j-1); - else - { - if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue); - else return addAttribute_WOSD(stringDup(lpszOldName),lpszNewValue); - } -} - -int XMLNode::indexText(XMLCSTR lpszValue) const -{ - if (!d) return -1; - int i,l=d->nText; - if (!lpszValue) { if (l) return 0; return -1; } - XMLCSTR *p=d->pText; - for (i=0; i=d->nText)) return; - d->nText--; - XMLCSTR *p=d->pText+i; - free((void*)*p); - if (d->nText) memmove(p,p+1,(d->nText-i)*sizeof(XMLCSTR)); else { free(p); d->pText=NULL; } - removeOrderElement(d,eNodeText,i); -} - -void XMLNode::deleteText(XMLCSTR lpszValue) { deleteText(indexText(lpszValue)); } - -XMLCSTR XMLNode::updateText_WOSD(XMLSTR lpszNewValue, int i) -{ - if (!d) { if (lpszNewValue) free(lpszNewValue); return NULL; } - if (i>=d->nText) return addText_WOSD(lpszNewValue); - XMLCSTR *p=d->pText+i; - if (*p!=lpszNewValue) { free((void*)*p); *p=lpszNewValue; } - return lpszNewValue; -} - -XMLCSTR XMLNode::updateText_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue) -{ - if (!d) { if (lpszNewValue) free(lpszNewValue); return NULL; } - int i=indexText(lpszOldValue); - if (i>=0) return updateText_WOSD(lpszNewValue,i); - return addText_WOSD(lpszNewValue); -} - -void XMLNode::deleteClear(int i) -{ - if ((!d)||(i<0)||(i>=d->nClear)) return; - d->nClear--; - XMLClear *p=d->pClear+i; - free((void*)p->lpszValue); - if (d->nClear) memmove(p,p+1,(d->nClear-i)*sizeof(XMLClear)); else { free(p); d->pClear=NULL; } - removeOrderElement(d,eNodeClear,i); -} - -int XMLNode::indexClear(XMLCSTR lpszValue) const -{ - if (!d) return -1; - int i,l=d->nClear; - if (!lpszValue) { if (l) return 0; return -1; } - XMLClear *p=d->pClear; - for (i=0; ilpszValue); } - -XMLClear *XMLNode::updateClear_WOSD(XMLSTR lpszNewContent, int i) -{ - if (!d) { if (lpszNewContent) free(lpszNewContent); return NULL; } - if (i>=d->nClear) return addClear_WOSD(lpszNewContent); - XMLClear *p=d->pClear+i; - if (lpszNewContent!=p->lpszValue) { free((void*)p->lpszValue); p->lpszValue=lpszNewContent; } - return p; -} - -XMLClear *XMLNode::updateClear_WOSD(XMLSTR lpszNewContent, XMLCSTR lpszOldValue) -{ - if (!d) { if (lpszNewContent) free(lpszNewContent); return NULL; } - int i=indexClear(lpszOldValue); - if (i>=0) return updateClear_WOSD(lpszNewContent,i); - return addClear_WOSD(lpszNewContent); -} - -XMLClear *XMLNode::updateClear_WOSD(XMLClear *newP,XMLClear *oldP) -{ - if (oldP) return updateClear_WOSD((XMLSTR)newP->lpszValue,(XMLSTR)oldP->lpszValue); - return NULL; -} - -int XMLNode::nChildNode(XMLCSTR name) const -{ - if (!d) return 0; - int i,j=0,n=d->nChild; - XMLNode *pc=d->pChild; - for (i=0; id->lpszName, name)==0) j++; - pc++; - } - return j; -} - -XMLNode XMLNode::getChildNode(XMLCSTR name, int *j) const -{ - if (!d) return emptyXMLNode; - int i=0,n=d->nChild; - if (j) i=*j; - XMLNode *pc=d->pChild+i; - for (; id->lpszName, name)) - { - if (j) *j=i+1; - return *pc; - } - pc++; - } - return emptyXMLNode; -} - -XMLNode XMLNode::getChildNode(XMLCSTR name, int j) const -{ - if (!d) return emptyXMLNode; - if (j>=0) - { - int i=0; - while (j-->0) getChildNode(name,&i); - return getChildNode(name,&i); - } - int i=d->nChild; - while (i--) if (!xstricmp(name,d->pChild[i].d->lpszName)) break; - if (i<0) return emptyXMLNode; - return getChildNode(i); -} - -XMLNode XMLNode::getChildNodeByPath(XMLCSTR _path, char createMissing, XMLCHAR sep) -{ - XMLSTR path=stringDup(_path); - XMLNode x=getChildNodeByPathNonConst(path,createMissing,sep); - if (path) free(path); - return x; -} - -XMLNode XMLNode::getChildNodeByPathNonConst(XMLSTR path, char createIfMissing, XMLCHAR sep) -{ - if ((!path)||(!(*path))) return *this; - XMLNode xn,xbase=*this; - XMLCHAR *tend1,sepString[2]; sepString[0]=sep; sepString[1]=0; - tend1=xstrstr(path,sepString); - while(tend1) - { - *tend1=0; - xn=xbase.getChildNode(path); - if (xn.isEmpty()) - { - if (createIfMissing) xn=xbase.addChild(path); - else { *tend1=sep; return XMLNode::emptyXMLNode; } - } - *tend1=sep; - xbase=xn; - path=tend1+1; - tend1=xstrstr(path,sepString); - } - xn=xbase.getChildNode(path); - if (xn.isEmpty()&&createIfMissing) xn=xbase.addChild(path); - return xn; -} - -XMLElementPosition XMLNode::positionOfText (int i) const { if (i>=d->nText ) i=d->nText-1; return findPosition(d,i,eNodeText ); } -XMLElementPosition XMLNode::positionOfClear (int i) const { if (i>=d->nClear) i=d->nClear-1; return findPosition(d,i,eNodeClear); } -XMLElementPosition XMLNode::positionOfChildNode(int i) const { if (i>=d->nChild) i=d->nChild-1; return findPosition(d,i,eNodeChild); } -XMLElementPosition XMLNode::positionOfText (XMLCSTR lpszValue) const { return positionOfText (indexText (lpszValue)); } -XMLElementPosition XMLNode::positionOfClear(XMLCSTR lpszValue) const { return positionOfClear(indexClear(lpszValue)); } -XMLElementPosition XMLNode::positionOfClear(XMLClear *a) const { if (a) return positionOfClear(a->lpszValue); return positionOfClear(); } -XMLElementPosition XMLNode::positionOfChildNode(XMLNode x) const -{ - if ((!d)||(!x.d)) return -1; - XMLNodeData *dd=x.d; - XMLNode *pc=d->pChild; - int i=d->nChild; - while (i--) if (pc[i].d==dd) return findPosition(d,i,eNodeChild); - return -1; -} -XMLElementPosition XMLNode::positionOfChildNode(XMLCSTR name, int count) const -{ - if (!name) return positionOfChildNode(count); - int j=0; - do { getChildNode(name,&j); if (j<0) return -1; } while (count--); - return findPosition(d,j-1,eNodeChild); -} - -XMLNode XMLNode::getChildNodeWithAttribute(XMLCSTR name,XMLCSTR attributeName,XMLCSTR attributeValue, int *k) const -{ - int i=0,j; - if (k) i=*k; - XMLNode x; - XMLCSTR t; - do - { - x=getChildNode(name,&i); - if (!x.isEmpty()) - { - if (attributeValue) - { - j=0; - do - { - t=x.getAttribute(attributeName,&j); - if (t&&(xstricmp(attributeValue,t)==0)) { if (k) *k=i; return x; } - } while (t); - } else - { - if (x.isAttributeSet(attributeName)) { if (k) *k=i; return x; } - } - } - } while (!x.isEmpty()); - return emptyXMLNode; -} - -// Find an attribute on an node. -XMLCSTR XMLNode::getAttribute(XMLCSTR lpszAttrib, int *j) const -{ - if (!d) return NULL; - int i=0,n=d->nAttribute; - if (j) i=*j; - XMLAttribute *pAttr=d->pAttribute+i; - for (; ilpszName, lpszAttrib)==0) - { - if (j) *j=i+1; - return pAttr->lpszValue; - } - pAttr++; - } - return NULL; -} - -char XMLNode::isAttributeSet(XMLCSTR lpszAttrib) const -{ - if (!d) return FALSE; - int i,n=d->nAttribute; - XMLAttribute *pAttr=d->pAttribute; - for (i=0; ilpszName, lpszAttrib)==0) - { - return TRUE; - } - pAttr++; - } - return FALSE; -} - -XMLCSTR XMLNode::getAttribute(XMLCSTR name, int j) const -{ - if (!d) return NULL; - int i=0; - while (j-->0) getAttribute(name,&i); - return getAttribute(name,&i); -} - -XMLNodeContents XMLNode::enumContents(int i) const -{ - XMLNodeContents c; - if (!d) { c.etype=eNodeNULL; return c; } - if (inAttribute) - { - c.etype=eNodeAttribute; - c.attrib=d->pAttribute[i]; - return c; - } - i-=d->nAttribute; - c.etype=(XMLElementType)(d->pOrder[i]&3); - i=(d->pOrder[i])>>2; - switch (c.etype) - { - case eNodeChild: c.child = d->pChild[i]; break; - case eNodeText: c.text = d->pText[i]; break; - case eNodeClear: c.clear = d->pClear[i]; break; - default: break; - } - return c; -} - -XMLCSTR XMLNode::getName() const { if (!d) return NULL; return d->lpszName; } -int XMLNode::nText() const { if (!d) return 0; return d->nText; } -int XMLNode::nChildNode() const { if (!d) return 0; return d->nChild; } -int XMLNode::nAttribute() const { if (!d) return 0; return d->nAttribute; } -int XMLNode::nClear() const { if (!d) return 0; return d->nClear; } -int XMLNode::nElement() const { if (!d) return 0; return d->nAttribute+d->nChild+d->nText+d->nClear; } -XMLClear XMLNode::getClear (int i) const { if ((!d)||(i>=d->nClear )) return emptyXMLClear; return d->pClear[i]; } -XMLAttribute XMLNode::getAttribute (int i) const { if ((!d)||(i>=d->nAttribute)) return emptyXMLAttribute; return d->pAttribute[i]; } -XMLCSTR XMLNode::getAttributeName (int i) const { if ((!d)||(i>=d->nAttribute)) return NULL; return d->pAttribute[i].lpszName; } -XMLCSTR XMLNode::getAttributeValue(int i) const { if ((!d)||(i>=d->nAttribute)) return NULL; return d->pAttribute[i].lpszValue; } -XMLCSTR XMLNode::getText (int i) const { if ((!d)||(i>=d->nText )) return NULL; return d->pText[i]; } -XMLNode XMLNode::getChildNode (int i) const { if ((!d)||(i>=d->nChild )) return emptyXMLNode; return d->pChild[i]; } -XMLNode XMLNode::getParentNode ( ) const { if ((!d)||(!d->pParent )) return emptyXMLNode; return XMLNode(d->pParent); } -char XMLNode::isDeclaration ( ) const { if (!d) return 0; return d->isDeclaration; } -char XMLNode::isEmpty ( ) const { return (d==NULL); } -XMLNode XMLNode::emptyNode ( ) { return XMLNode::emptyXMLNode; } - -XMLNode XMLNode::addChild(XMLCSTR lpszName, char isDeclaration, XMLElementPosition pos) - { return addChild_priv(0,stringDup(lpszName),isDeclaration,pos); } -XMLNode XMLNode::addChild_WOSD(XMLSTR lpszName, char isDeclaration, XMLElementPosition pos) - { return addChild_priv(0,lpszName,isDeclaration,pos); } -XMLAttribute *XMLNode::addAttribute(XMLCSTR lpszName, XMLCSTR lpszValue) - { return addAttribute_priv(0,stringDup(lpszName),stringDup(lpszValue)); } -XMLAttribute *XMLNode::addAttribute_WOSD(XMLSTR lpszName, XMLSTR lpszValuev) - { return addAttribute_priv(0,lpszName,lpszValuev); } -XMLCSTR XMLNode::addText(XMLCSTR lpszValue, XMLElementPosition pos) - { return addText_priv(0,stringDup(lpszValue),pos); } -XMLCSTR XMLNode::addText_WOSD(XMLSTR lpszValue, XMLElementPosition pos) - { return addText_priv(0,lpszValue,pos); } -XMLClear *XMLNode::addClear(XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, XMLElementPosition pos) - { return addClear_priv(0,stringDup(lpszValue),lpszOpen,lpszClose,pos); } -XMLClear *XMLNode::addClear_WOSD(XMLSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, XMLElementPosition pos) - { return addClear_priv(0,lpszValue,lpszOpen,lpszClose,pos); } -XMLCSTR XMLNode::updateName(XMLCSTR lpszName) - { return updateName_WOSD(stringDup(lpszName)); } -XMLAttribute *XMLNode::updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute) - { return updateAttribute_WOSD(stringDup(newAttribute->lpszValue),stringDup(newAttribute->lpszName),oldAttribute->lpszName); } -XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,int i) - { return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),i); } -XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName) - { return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),lpszOldName); } -XMLCSTR XMLNode::updateText(XMLCSTR lpszNewValue, int i) - { return updateText_WOSD(stringDup(lpszNewValue),i); } -XMLCSTR XMLNode::updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue) - { return updateText_WOSD(stringDup(lpszNewValue),lpszOldValue); } -XMLClear *XMLNode::updateClear(XMLCSTR lpszNewContent, int i) - { return updateClear_WOSD(stringDup(lpszNewContent),i); } -XMLClear *XMLNode::updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue) - { return updateClear_WOSD(stringDup(lpszNewValue),lpszOldValue); } -XMLClear *XMLNode::updateClear(XMLClear *newP,XMLClear *oldP) - { return updateClear_WOSD(stringDup(newP->lpszValue),oldP->lpszValue); } - -char XMLNode::setGlobalOptions(XMLCharEncoding _characterEncoding, char _guessWideCharChars, - char _dropWhiteSpace, char _removeCommentsInMiddleOfText) -{ - guessWideCharChars=_guessWideCharChars; dropWhiteSpace=_dropWhiteSpace; removeCommentsInMiddleOfText=_removeCommentsInMiddleOfText; -#ifdef _XMLWIDECHAR - if (_characterEncoding) characterEncoding=_characterEncoding; -#else - switch(_characterEncoding) - { - case char_encoding_UTF8: characterEncoding=_characterEncoding; XML_ByteTable=XML_utf8ByteTable; break; - case char_encoding_legacy: characterEncoding=_characterEncoding; XML_ByteTable=XML_legacyByteTable; break; - case char_encoding_ShiftJIS: characterEncoding=_characterEncoding; XML_ByteTable=XML_sjisByteTable; break; - case char_encoding_GB2312: characterEncoding=_characterEncoding; XML_ByteTable=XML_gb2312ByteTable; break; - case char_encoding_Big5: - case char_encoding_GBK: characterEncoding=_characterEncoding; XML_ByteTable=XML_gbk_big5_ByteTable; break; - default: return 1; - } -#endif - return 0; -} - -XMLNode::XMLCharEncoding XMLNode::guessCharEncoding(void *buf,int l, char useXMLEncodingAttribute) -{ -#ifdef _XMLWIDECHAR - return (XMLCharEncoding)0; -#else - if (l<25) return (XMLCharEncoding)0; - if (guessWideCharChars&&(myIsTextWideChar(buf,l))) return (XMLCharEncoding)0; - unsigned char *b=(unsigned char*)buf; - if ((b[0]==0xef)&&(b[1]==0xbb)&&(b[2]==0xbf)) return char_encoding_UTF8; - - // Match utf-8 model ? - XMLCharEncoding bestGuess=char_encoding_UTF8; - int i=0; - while (i>2 ]; - *(curr++)=base64EncodeTable[(inbuf[0]<<4)&0x3F]; - *(curr++)=base64Fillchar; - *(curr++)=base64Fillchar; - } else if (eLen==2) - { - j=(inbuf[0]<<8)|inbuf[1]; - *(curr++)=base64EncodeTable[ j>>10 ]; - *(curr++)=base64EncodeTable[(j>> 4)&0x3f]; - *(curr++)=base64EncodeTable[(j<< 2)&0x3f]; - *(curr++)=base64Fillchar; - } - *(curr++)=0; - return (XMLSTR)buf; -} - -unsigned int XMLParserBase64Tool::decodeSize(XMLCSTR data,XMLError *xe) -{ - if (!data) return 0; - if (xe) *xe=eXMLErrorNone; - int size=0; - unsigned char c; - //skip any extra characters (e.g. newlines or spaces) - while (*data) - { -#ifdef _XMLWIDECHAR - if (*data>255) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; } -#endif - c=base64DecodeTable[(unsigned char)(*data)]; - if (c<97) size++; - else if (c==98) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; } - data++; - } - if (xe&&(size%4!=0)) *xe=eXMLErrorBase64DataSizeIsNotMultipleOf4; - if (size==0) return 0; - do { data--; size--; } while(*data==base64Fillchar); size++; - return (unsigned int)((size*3)/4); -} - -unsigned char XMLParserBase64Tool::decode(XMLCSTR data, unsigned char *buf, int len, XMLError *xe) -{ - if (!data) return 0; - if (xe) *xe=eXMLErrorNone; - int i=0,p=0; - unsigned char d,c; - for(;;) - { - -#ifdef _XMLWIDECHAR -#define BASE64DECODE_READ_NEXT_CHAR(c) \ - do { \ - if (data[i]>255){ c=98; break; } \ - c=base64DecodeTable[(unsigned char)data[i++]]; \ - }while (c==97); \ - if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; } -#else -#define BASE64DECODE_READ_NEXT_CHAR(c) \ - do { c=base64DecodeTable[(unsigned char)data[i++]]; }while (c==97); \ - if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; } -#endif - - BASE64DECODE_READ_NEXT_CHAR(c) - if (c==99) { return 2; } - if (c==96) - { - if (p==(int)len) return 2; - if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; - return 1; - } - - BASE64DECODE_READ_NEXT_CHAR(d) - if ((d==99)||(d==96)) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; } - if (p==(int)len) { if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall; return 0; } - buf[p++]=(unsigned char)((c<<2)|((d>>4)&0x3)); - - BASE64DECODE_READ_NEXT_CHAR(c) - if (c==99) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; } - if (p==(int)len) - { - if (c==96) return 2; - if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall; - return 0; - } - if (c==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; } - buf[p++]=(unsigned char)(((d<<4)&0xf0)|((c>>2)&0xf)); - - BASE64DECODE_READ_NEXT_CHAR(d) - if (d==99 ) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; } - if (p==(int)len) - { - if (d==96) return 2; - if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall; - return 0; - } - if (d==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData; return 1; } - buf[p++]=(unsigned char)(((c<<6)&0xc0)|d); - } -} -#undef BASE64DECODE_READ_NEXT_CHAR - -void XMLParserBase64Tool::alloc(int newsize) -{ - if ((!buf)&&(newsize)) { buf=malloc(newsize); buflen=newsize; return; } - if (newsize>buflen) { buf=realloc(buf,newsize); buflen=newsize; } -} - -unsigned char *XMLParserBase64Tool::decode(XMLCSTR data, int *outlen, XMLError *xe) -{ - if (xe) *xe=eXMLErrorNone; - if (!data) { *outlen=0; return (unsigned char*)""; } - unsigned int len=decodeSize(data,xe); - if (outlen) *outlen=len; - if (!len) return NULL; - alloc(len+1); - if(!decode(data,(unsigned char*)buf,len,xe)){ return NULL; } - return (unsigned char*)buf; -} - diff --git a/source/common/xmlParser.h b/source/common/xmlParser.h deleted file mode 100644 index 1187165..0000000 --- a/source/common/xmlParser.h +++ /dev/null @@ -1,732 +0,0 @@ -/****************************************************************************/ -/*! \mainpage XMLParser library - * \section intro_sec Introduction - * - * This is a basic XML parser written in ANSI C++ for portability. - * It works by using recursion and a node tree for breaking - * down the elements of an XML document. - * - * @version V2.44 - * @author Frank Vanden Berghen - * - * Copyright (c) 2002, Frank Vanden Berghen - All rights reserved.
- * Commercialized by Business-Insight
- * See the file AFPL-license.txt about the licensing terms - * - * \section tutorial First Tutorial - * You can follow a simple Tutorial to know the basics... - * - * \section usage General usage: How to include the XMLParser library inside your project. - * - * The library is composed of two files: xmlParser.cpp and - * xmlParser.h. These are the ONLY 2 files that you need when - * using the library inside your own projects. - * - * All the functions of the library are documented inside the comments of the file - * xmlParser.h. These comments can be transformed in - * full-fledged HTML documentation using the DOXYGEN software: simply type: "doxygen doxy.cfg" - * - * By default, the XMLParser library uses (char*) for string representation.To use the (wchar_t*) - * version of the library, you need to define the "_UNICODE" preprocessor definition variable - * (this is usually done inside your project definition file) (This is done automatically for you - * when using Visual Studio). - * - * \section example Advanced Tutorial and Many Examples of usage. - * - * Some very small introductory examples are described inside the Tutorial file - * xmlParser.html - * - * Some additional small examples are also inside the file xmlTest.cpp - * (for the "char*" version of the library) and inside the file - * xmlTestUnicode.cpp (for the "wchar_t*" - * version of the library). If you have a question, please review these additionnal examples - * before sending an e-mail to the author. - * - * To build the examples: - * - linux/unix: type "make" - * - solaris: type "make -f makefile.solaris" - * - windows: Visual Studio: double-click on xmlParser.dsw - * (under Visual Studio .NET, the .dsp and .dsw files will be automatically converted to .vcproj and .sln files) - * - * In order to build the examples you need some additional files: - * - linux/unix: makefile - * - solaris: makefile.solaris - * - windows: Visual Studio: *.dsp, xmlParser.dsw and also xmlParser.lib and xmlParser.dll - * - * \section debugging Debugging with the XMLParser library - * - * \subsection debugwin Debugging under WINDOWS - * - * Inside Visual C++, the "debug versions" of the memory allocation functions are - * very slow: Do not forget to compile in "release mode" to get maximum speed. - * When I had to debug a software that was using the XMLParser Library, it was usually - * a nightmare because the library was sooOOOoooo slow in debug mode (because of the - * slow memory allocations in Debug mode). To solve this - * problem, during all the debugging session, I am now using a very fast DLL version of the - * XMLParser Library (the DLL is compiled in release mode). Using the DLL version of - * the XMLParser Library allows me to have lightening XML parsing speed even in debug! - * Other than that, the DLL version is useless: In the release version of my tool, - * I always use the normal, ".cpp"-based, XMLParser Library (I simply include the - * xmlParser.cpp and - * xmlParser.h files into the project). - * - * The file XMLNodeAutoexp.txt contains some - * "tweaks" that improve substancially the display of the content of the XMLNode objects - * inside the Visual Studio Debugger. Believe me, once you have seen inside the debugger - * the "smooth" display of the XMLNode objects, you cannot live without it anymore! - * - * \subsection debuglinux Debugging under LINUX/UNIX - * - * The speed of the debug version of the XMLParser library is tolerable so no extra - * work.has been done. - * - ****************************************************************************/ - -#ifndef __INCLUDE_XML_NODE__ -#define __INCLUDE_XML_NODE__ - -#include - -#if defined(UNICODE) || defined(_UNICODE) -// If you comment the next "define" line then the library will never "switch to" _UNICODE (wchar_t*) mode (16/32 bits per characters). -// This is useful when you get error messages like: -// 'XMLNode::openFileHelper' : cannot convert parameter 2 from 'const char [5]' to 'const wchar_t *' -// The _XMLWIDECHAR preprocessor variable force the XMLParser library into either utf16/32-mode (the proprocessor variable -// must be defined) or utf8-mode(the pre-processor variable must be undefined). -#define _XMLWIDECHAR -#endif - -#if defined(WIN32) || defined(UNDER_CE) || defined(_WIN32) || defined(WIN64) || defined(__BORLANDC__) -// comment the next line if you are under windows and the compiler is not Microsoft Visual Studio (6.0 or .NET) or Borland -#define _XMLWINDOWS -#endif - -#ifdef XMLDLLENTRY -#undef XMLDLLENTRY -#endif -#ifdef _USE_XMLPARSER_DLL -#ifdef _DLL_EXPORTS_ -#define XMLDLLENTRY __declspec(dllexport) -#else -#define XMLDLLENTRY __declspec(dllimport) -#endif -#else -#define XMLDLLENTRY -#endif - -// uncomment the next line if you want no support for wchar_t* (no need for the or libraries anymore to compile) -//#define XML_NO_WIDE_CHAR - -#ifdef XML_NO_WIDE_CHAR -#undef _XMLWINDOWS -#undef _XMLWIDECHAR -#endif - -#ifdef _XMLWINDOWS -#include -#else -#define XMLDLLENTRY -#ifndef XML_NO_WIDE_CHAR -#include // to have 'wcsrtombs' for ANSI version - // to have 'mbsrtowcs' for WIDECHAR version -#endif -#endif - -// Some common types for char set portable code -#ifdef _XMLWIDECHAR - #define _CXML(c) L ## c - #define XMLCSTR const wchar_t * - #define XMLSTR wchar_t * - #define XMLCHAR wchar_t -#else - #define _CXML(c) c - #define XMLCSTR const char * - #define XMLSTR char * - #define XMLCHAR char -#endif -#ifndef FALSE - #define FALSE 0 -#endif /* FALSE */ -#ifndef TRUE - #define TRUE 1 -#endif /* TRUE */ - - -/// Enumeration for XML parse errors. -typedef enum XMLError -{ - eXMLErrorNone = 0, - eXMLErrorMissingEndTag, - eXMLErrorNoXMLTagFound, - eXMLErrorEmpty, - eXMLErrorMissingTagName, - eXMLErrorMissingEndTagName, - eXMLErrorUnmatchedEndTag, - eXMLErrorUnmatchedEndClearTag, - eXMLErrorUnexpectedToken, - eXMLErrorNoElements, - eXMLErrorFileNotFound, - eXMLErrorFirstTagNotFound, - eXMLErrorUnknownCharacterEntity, - eXMLErrorCharacterCodeAbove255, - eXMLErrorCharConversionError, - eXMLErrorCannotOpenWriteFile, - eXMLErrorCannotWriteFile, - - eXMLErrorBase64DataSizeIsNotMultipleOf4, - eXMLErrorBase64DecodeIllegalCharacter, - eXMLErrorBase64DecodeTruncatedData, - eXMLErrorBase64DecodeBufferTooSmall -} XMLError; - - -/// Enumeration used to manage type of data. Use in conjunction with structure XMLNodeContents -typedef enum XMLElementType -{ - eNodeChild=0, - eNodeAttribute=1, - eNodeText=2, - eNodeClear=3, - eNodeNULL=4 -} XMLElementType; - -/// Structure used to obtain error details if the parse fails. -typedef struct XMLResults -{ - enum XMLError error; - int nLine,nColumn; -} XMLResults; - -/// Structure for XML clear (unformatted) node (usually comments) -typedef struct XMLClear { - XMLCSTR lpszValue; XMLCSTR lpszOpenTag; XMLCSTR lpszCloseTag; -} XMLClear; - -/// Structure for XML attribute. -typedef struct XMLAttribute { - XMLCSTR lpszName; XMLCSTR lpszValue; -} XMLAttribute; - -/// XMLElementPosition are not interchangeable with simple indexes -typedef int XMLElementPosition; - -struct XMLNodeContents; - -/** @defgroup XMLParserGeneral The XML parser */ - -/// Main Class representing a XML node -/** - * All operations are performed using this class. - * \note The constructors of the XMLNode class are protected, so use instead one of these four methods to get your first instance of XMLNode: - *
    - *
  • XMLNode::parseString
    • - *
  • XMLNode::parseFile
    • - *
  • XMLNode::openFileHelper
    • - *
  • XMLNode::createXMLTopNode (or XMLNode::createXMLTopNode_WOSD)
    • - *
*/ -typedef struct XMLDLLENTRY XMLNode -{ - private: - - struct XMLNodeDataTag; - - /// Constructors are protected, so use instead one of: XMLNode::parseString, XMLNode::parseFile, XMLNode::openFileHelper, XMLNode::createXMLTopNode - XMLNode(struct XMLNodeDataTag *pParent, XMLSTR lpszName, char isDeclaration); - /// Constructors are protected, so use instead one of: XMLNode::parseString, XMLNode::parseFile, XMLNode::openFileHelper, XMLNode::createXMLTopNode - XMLNode(struct XMLNodeDataTag *p); - - public: - static XMLCSTR getVersion();///< Return the XMLParser library version number - - /** @defgroup conversions Parsing XML files/strings to an XMLNode structure and Rendering XMLNode's to files/string. - * @ingroup XMLParserGeneral - * @{ */ - - /// Parse an XML string and return the root of a XMLNode tree representing the string. - static XMLNode parseString (XMLCSTR lpXMLString, XMLCSTR tag=NULL, XMLResults *pResults=NULL); - /**< The "parseString" function parse an XML string and return the root of a XMLNode tree. The "opposite" of this function is - * the function "createXMLString" that re-creates an XML string from an XMLNode tree. If the XML document is corrupted, the - * "parseString" method will initialize the "pResults" variable with some information that can be used to trace the error. - * If you still want to parse the file, you can use the APPROXIMATE_PARSING option as explained inside the note at the - * beginning of the "xmlParser.cpp" file. - * - * @param lpXMLString the XML string to parse - * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (). - * @param pResults a pointer to a XMLResults variable that will contain some information that can be used to trace the XML parsing error. You can have a user-friendly explanation of the parsing error with the "getError" function. - */ - - /// Parse an XML file and return the root of a XMLNode tree representing the file. - static XMLNode parseFile (XMLCSTR filename, XMLCSTR tag=NULL, XMLResults *pResults=NULL); - /**< The "parseFile" function parse an XML file and return the root of a XMLNode tree. The "opposite" of this function is - * the function "writeToFile" that re-creates an XML file from an XMLNode tree. If the XML document is corrupted, the - * "parseFile" method will initialize the "pResults" variable with some information that can be used to trace the error. - * If you still want to parse the file, you can use the APPROXIMATE_PARSING option as explained inside the note at the - * beginning of the "xmlParser.cpp" file. - * - * @param filename the path to the XML file to parse - * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (). - * @param pResults a pointer to a XMLResults variable that will contain some information that can be used to trace the XML parsing error. You can have a user-friendly explanation of the parsing error with the "getError" function. - */ - - /// Parse an XML file and return the root of a XMLNode tree representing the file. A very crude error checking is made. An attempt to guess the Char Encoding used in the file is made. - static XMLNode openFileHelper(XMLCSTR filename, XMLCSTR tag=NULL); - /**< The "openFileHelper" function reports to the screen all the warnings and errors that occurred during parsing of the XML file. - * This function also tries to guess char Encoding (UTF-8, ASCII or SHIT-JIS) based on the first 200 bytes of the file. Since each - * application has its own way to report and deal with errors, you should rather use the "parseFile" function to parse XML files - * and program yourself thereafter an "error reporting" tailored for your needs (instead of using the very crude "error reporting" - * mechanism included inside the "openFileHelper" function). - * - * If the XML document is corrupted, the "openFileHelper" method will: - * - display an error message on the console (or inside a messageBox for windows). - * - stop execution (exit). - * - * I strongly suggest that you write your own "openFileHelper" method tailored to your needs. If you still want to parse - * the file, you can use the APPROXIMATE_PARSING option as explained inside the note at the beginning of the "xmlParser.cpp" file. - * - * @param filename the path of the XML file to parse. - * @param tag the name of the first tag inside the XML file. If the tag parameter is omitted, this function returns a node that represents the head of the xml document including the declaration term (). - */ - - static XMLCSTR getError(XMLError error); ///< this gives you a user-friendly explanation of the parsing error - - /// Create an XML string starting from the current XMLNode. - XMLSTR createXMLString(int nFormat=1, int *pnSize=NULL) const; - /**< The returned string should be free'd using the "freeXMLString" function. - * - * If nFormat==0, no formatting is required otherwise this returns an user friendly XML string from a given element - * with appropriate white spaces and carriage returns. if pnSize is given it returns the size in character of the string. */ - - /// Save the content of an xmlNode inside a file - XMLError writeToFile(XMLCSTR filename, - const char *encoding=NULL, - char nFormat=1) const; - /**< If nFormat==0, no formatting is required otherwise this returns an user friendly XML string from a given element with appropriate white spaces and carriage returns. - * If the global parameter "characterEncoding==encoding_UTF8", then the "encoding" parameter is ignored and always set to "utf-8". - * If the global parameter "characterEncoding==encoding_ShiftJIS", then the "encoding" parameter is ignored and always set to "SHIFT-JIS". - * If "_XMLWIDECHAR=1", then the "encoding" parameter is ignored and always set to "utf-16". - * If no "encoding" parameter is given the "ISO-8859-1" encoding is used. */ - /** @} */ - - /** @defgroup navigate Navigate the XMLNode structure - * @ingroup XMLParserGeneral - * @{ */ - XMLCSTR getName() const; ///< name of the node - XMLCSTR getText(int i=0) const; ///< return ith text field - int nText() const; ///< nbr of text field - XMLNode getParentNode() const; ///< return the parent node - XMLNode getChildNode(int i=0) const; ///< return ith child node - XMLNode getChildNode(XMLCSTR name, int i) const; ///< return ith child node with specific name (return an empty node if failing). If i==-1, this returns the last XMLNode with the given name. - XMLNode getChildNode(XMLCSTR name, int *i=NULL) const; ///< return next child node with specific name (return an empty node if failing) - XMLNode getChildNodeWithAttribute(XMLCSTR tagName, - XMLCSTR attributeName, - XMLCSTR attributeValue=NULL, - int *i=NULL) const; ///< return child node with specific name/attribute (return an empty node if failing) - XMLNode getChildNodeByPath(XMLCSTR path, char createNodeIfMissing=0, XMLCHAR sep='/'); - ///< return the first child node with specific path - XMLNode getChildNodeByPathNonConst(XMLSTR path, char createNodeIfMissing=0, XMLCHAR sep='/'); - ///< return the first child node with specific path. - - int nChildNode(XMLCSTR name) const; ///< return the number of child node with specific name - int nChildNode() const; ///< nbr of child node - XMLAttribute getAttribute(int i=0) const; ///< return ith attribute - XMLCSTR getAttributeName(int i=0) const; ///< return ith attribute name - XMLCSTR getAttributeValue(int i=0) const; ///< return ith attribute value - char isAttributeSet(XMLCSTR name) const; ///< test if an attribute with a specific name is given - XMLCSTR getAttribute(XMLCSTR name, int i) const; ///< return ith attribute content with specific name (return a NULL if failing) - XMLCSTR getAttribute(XMLCSTR name, int *i=NULL) const; ///< return next attribute content with specific name (return a NULL if failing) - int nAttribute() const; ///< nbr of attribute - XMLClear getClear(int i=0) const; ///< return ith clear field (comments) - int nClear() const; ///< nbr of clear field - XMLNodeContents enumContents(XMLElementPosition i) const; ///< enumerate all the different contents (attribute,child,text, clear) of the current XMLNode. The order is reflecting the order of the original file/string. NOTE: 0 <= i < nElement(); - int nElement() const; ///< nbr of different contents for current node - char isEmpty() const; ///< is this node Empty? - char isDeclaration() const; ///< is this node a declaration - XMLNode deepCopy() const; ///< deep copy (duplicate/clone) a XMLNode - static XMLNode emptyNode(); ///< return XMLNode::emptyXMLNode; - /** @} */ - - ~XMLNode(); - XMLNode(const XMLNode &A); ///< to allow shallow/fast copy: - XMLNode& operator=( const XMLNode& A ); ///< to allow shallow/fast copy: - - XMLNode(): d(NULL){}; - static XMLNode emptyXMLNode; - static XMLClear emptyXMLClear; - static XMLAttribute emptyXMLAttribute; - - /** @defgroup xmlModify Create or Update the XMLNode structure - * @ingroup XMLParserGeneral - * The functions in this group allows you to create from scratch (or update) a XMLNode structure. Start by creating your top - * node with the "createXMLTopNode" function and then add new nodes with the "addChild" function. The parameter 'pos' gives - * the position where the childNode, the text or the XMLClearTag will be inserted. The default value (pos=-1) inserts at the - * end. The value (pos=0) insert at the beginning (Insertion at the beginning is slower than at the end).
- * - * REMARK: 0 <= pos < nChild()+nText()+nClear()
- */ - - /** @defgroup creation Creating from scratch a XMLNode structure - * @ingroup xmlModify - * @{ */ - static XMLNode createXMLTopNode(XMLCSTR lpszName, char isDeclaration=FALSE); ///< Create the top node of an XMLNode structure - XMLNode addChild(XMLCSTR lpszName, char isDeclaration=FALSE, XMLElementPosition pos=-1); ///< Add a new child node - XMLNode addChild(XMLNode nodeToAdd, XMLElementPosition pos=-1); ///< If the "nodeToAdd" has some parents, it will be detached from it's parents before being attached to the current XMLNode - XMLAttribute *addAttribute(XMLCSTR lpszName, XMLCSTR lpszValuev); ///< Add a new attribute - XMLCSTR addText(XMLCSTR lpszValue, XMLElementPosition pos=-1); ///< Add a new text content - XMLClear *addClear(XMLCSTR lpszValue, XMLCSTR lpszOpen=NULL, XMLCSTR lpszClose=NULL, XMLElementPosition pos=-1); - /**< Add a new clear tag - * @param lpszOpen default value "" - */ - /** @} */ - - /** @defgroup xmlUpdate Updating Nodes - * @ingroup xmlModify - * Some update functions: - * @{ - */ - XMLCSTR updateName(XMLCSTR lpszName); ///< change node's name - XMLAttribute *updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute); ///< if the attribute to update is missing, a new one will be added - XMLAttribute *updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName=NULL,int i=0); ///< if the attribute to update is missing, a new one will be added - XMLAttribute *updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName);///< set lpszNewName=NULL if you don't want to change the name of the attribute if the attribute to update is missing, a new one will be added - XMLCSTR updateText(XMLCSTR lpszNewValue, int i=0); ///< if the text to update is missing, a new one will be added - XMLCSTR updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the text to update is missing, a new one will be added - XMLClear *updateClear(XMLCSTR lpszNewContent, int i=0); ///< if the clearTag to update is missing, a new one will be added - XMLClear *updateClear(XMLClear *newP,XMLClear *oldP); ///< if the clearTag to update is missing, a new one will be added - XMLClear *updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the clearTag to update is missing, a new one will be added - /** @} */ - - /** @defgroup xmlDelete Deleting Nodes or Attributes - * @ingroup xmlModify - * Some deletion functions: - * @{ - */ - /// The "deleteNodeContent" function forces the deletion of the content of this XMLNode and the subtree. - void deleteNodeContent(); - /**< \note The XMLNode instances that are referring to the part of the subtree that has been deleted CANNOT be used anymore!!. Unexpected results will occur if you continue using them. */ - void deleteAttribute(int i=0); ///< Delete the ith attribute of the current XMLNode - void deleteAttribute(XMLCSTR lpszName); ///< Delete the attribute with the given name (the "strcmp" function is used to find the right attribute) - void deleteAttribute(XMLAttribute *anAttribute); ///< Delete the attribute with the name "anAttribute->lpszName" (the "strcmp" function is used to find the right attribute) - void deleteText(int i=0); ///< Delete the Ith text content of the current XMLNode - void deleteText(XMLCSTR lpszValue); ///< Delete the text content "lpszValue" inside the current XMLNode (direct "pointer-to-pointer" comparison is used to find the right text) - void deleteClear(int i=0); ///< Delete the Ith clear tag inside the current XMLNode - void deleteClear(XMLCSTR lpszValue); ///< Delete the clear tag "lpszValue" inside the current XMLNode (direct "pointer-to-pointer" comparison is used to find the clear tag) - void deleteClear(XMLClear *p); ///< Delete the clear tag "p" inside the current XMLNode (direct "pointer-to-pointer" comparison on the lpszName of the clear tag is used to find the clear tag) - /** @} */ - - /** @defgroup xmlWOSD ???_WOSD functions. - * @ingroup xmlModify - * The strings given as parameters for the "add" and "update" methods that have a name with - * the postfix "_WOSD" (that means "WithOut String Duplication")(for example "addText_WOSD") - * will be free'd by the XMLNode class. For example, it means that this is incorrect: - * \code - * xNode.addText_WOSD("foo"); - * xNode.updateAttribute_WOSD("#newcolor" ,NULL,"color"); - * \endcode - * In opposition, this is correct: - * \code - * xNode.addText("foo"); - * xNode.addText_WOSD(stringDup("foo")); - * xNode.updateAttribute("#newcolor" ,NULL,"color"); - * xNode.updateAttribute_WOSD(stringDup("#newcolor"),NULL,"color"); - * \endcode - * Typically, you will never do: - * \code - * char *b=(char*)malloc(...); - * xNode.addText(b); - * free(b); - * \endcode - * ... but rather: - * \code - * char *b=(char*)malloc(...); - * xNode.addText_WOSD(b); - * \endcode - * ('free(b)' is performed by the XMLNode class) - * @{ */ - static XMLNode createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration=FALSE); ///< Create the top node of an XMLNode structure - XMLNode addChild_WOSD(XMLSTR lpszName, char isDeclaration=FALSE, XMLElementPosition pos=-1); ///< Add a new child node - XMLAttribute *addAttribute_WOSD(XMLSTR lpszName, XMLSTR lpszValue); ///< Add a new attribute - XMLCSTR addText_WOSD(XMLSTR lpszValue, XMLElementPosition pos=-1); ///< Add a new text content - XMLClear *addClear_WOSD(XMLSTR lpszValue, XMLCSTR lpszOpen=NULL, XMLCSTR lpszClose=NULL, XMLElementPosition pos=-1); ///< Add a new clear Tag - - XMLCSTR updateName_WOSD(XMLSTR lpszName); ///< change node's name - XMLAttribute *updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute); ///< if the attribute to update is missing, a new one will be added - XMLAttribute *updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName=NULL,int i=0); ///< if the attribute to update is missing, a new one will be added - XMLAttribute *updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName,XMLCSTR lpszOldName); ///< set lpszNewName=NULL if you don't want to change the name of the attribute if the attribute to update is missing, a new one will be added - XMLCSTR updateText_WOSD(XMLSTR lpszNewValue, int i=0); ///< if the text to update is missing, a new one will be added - XMLCSTR updateText_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the text to update is missing, a new one will be added - XMLClear *updateClear_WOSD(XMLSTR lpszNewContent, int i=0); ///< if the clearTag to update is missing, a new one will be added - XMLClear *updateClear_WOSD(XMLClear *newP,XMLClear *oldP); ///< if the clearTag to update is missing, a new one will be added - XMLClear *updateClear_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue); ///< if the clearTag to update is missing, a new one will be added - /** @} */ - - /** @defgroup xmlPosition Position helper functions (use in conjunction with the update&add functions - * @ingroup xmlModify - * These are some useful functions when you want to insert a childNode, a text or a XMLClearTag in the - * middle (at a specified position) of a XMLNode tree already constructed. The value returned by these - * methods is to be used as last parameter (parameter 'pos') of addChild, addText or addClear. - * @{ */ - XMLElementPosition positionOfText(int i=0) const; - XMLElementPosition positionOfText(XMLCSTR lpszValue) const; - XMLElementPosition positionOfClear(int i=0) const; - XMLElementPosition positionOfClear(XMLCSTR lpszValue) const; - XMLElementPosition positionOfClear(XMLClear *a) const; - XMLElementPosition positionOfChildNode(int i=0) const; - XMLElementPosition positionOfChildNode(XMLNode x) const; - XMLElementPosition positionOfChildNode(XMLCSTR name, int i=0) const; ///< return the position of the ith childNode with the specified name if (name==NULL) return the position of the ith childNode - /** @} */ - - /// Enumeration for XML character encoding. - typedef enum XMLCharEncoding - { - char_encoding_error=0, - char_encoding_UTF8=1, - char_encoding_legacy=2, - char_encoding_ShiftJIS=3, - char_encoding_GB2312=4, - char_encoding_Big5=5, - char_encoding_GBK=6 // this is actually the same as Big5 - } XMLCharEncoding; - - /** \addtogroup conversions - * @{ */ - - /// Sets the global options for the conversions - static char setGlobalOptions(XMLCharEncoding characterEncoding=XMLNode::char_encoding_UTF8, char guessWideCharChars=1, - char dropWhiteSpace=1, char removeCommentsInMiddleOfText=1); - /**< The "setGlobalOptions" function allows you to change four global parameters that affect string & file - * parsing. First of all, you most-probably will never have to change these 3 global parameters. - * - * @param guessWideCharChars If "guessWideCharChars"=1 and if this library is compiled in WideChar mode, then the - * XMLNode::parseFile and XMLNode::openFileHelper functions will test if the file contains ASCII - * characters. If this is the case, then the file will be loaded and converted in memory to - * WideChar before being parsed. If 0, no conversion will be performed. - * - * @param guessWideCharChars If "guessWideCharChars"=1 and if this library is compiled in ASCII/UTF8/char* mode, then the - * XMLNode::parseFile and XMLNode::openFileHelper functions will test if the file contains WideChar - * characters. If this is the case, then the file will be loaded and converted in memory to - * ASCII/UTF8/char* before being parsed. If 0, no conversion will be performed. - * - * @param characterEncoding This parameter is only meaningful when compiling in char* mode (multibyte character mode). - * In wchar_t* (wide char mode), this parameter is ignored. This parameter should be one of the - * three currently recognized encodings: XMLNode::encoding_UTF8, XMLNode::encoding_ascii, - * XMLNode::encoding_ShiftJIS. - * - * @param dropWhiteSpace In most situations, text fields containing only white spaces (and carriage returns) - * are useless. Even more, these "empty" text fields are annoying because they increase the - * complexity of the user's code for parsing. So, 99% of the time, it's better to drop - * the "empty" text fields. However The XML specification indicates that no white spaces - * should be lost when parsing the file. So to be perfectly XML-compliant, you should set - * dropWhiteSpace=0. A note of caution: if you set "dropWhiteSpace=0", the parser will be - * slower and your code will be more complex. - * - * @param removeCommentsInMiddleOfText To explain this parameter, let's consider this code: - * \code - * XMLNode x=XMLNode::parseString("foobarchu","a"); - * \endcode - * If removeCommentsInMiddleOfText=0, then we will have: - * \code - * x.getText(0) -> "foo" - * x.getText(1) -> "bar" - * x.getText(2) -> "chu" - * x.getClear(0) --> "" - * x.getClear(1) --> "" - * \endcode - * If removeCommentsInMiddleOfText=1, then we will have: - * \code - * x.getText(0) -> "foobar" - * x.getText(1) -> "chu" - * x.getClear(0) --> "" - * \endcode - * - * \return "0" when there are no errors. If you try to set an unrecognized encoding then the return value will be "1" to signal an error. - * - * \note Sometime, it's useful to set "guessWideCharChars=0" to disable any conversion - * because the test to detect the file-type (ASCII/UTF8/char* or WideChar) may fail (rarely). */ - - /// Guess the character encoding of the string (ascii, utf8 or shift-JIS) - static XMLCharEncoding guessCharEncoding(void *buffer, int bufLen, char useXMLEncodingAttribute=1); - /**< The "guessCharEncoding" function try to guess the character encoding. You most-probably will never - * have to use this function. It then returns the appropriate value of the global parameter - * "characterEncoding" described in the XMLNode::setGlobalOptions. The guess is based on the content of a buffer of length - * "bufLen" bytes that contains the first bytes (minimum 25 bytes; 200 bytes is a good value) of the - * file to be parsed. The XMLNode::openFileHelper function is using this function to automatically compute - * the value of the "characterEncoding" global parameter. There are several heuristics used to do the - * guess. One of the heuristic is based on the "encoding" attribute. The original XML specifications - * forbids to use this attribute to do the guess but you can still use it if you set - * "useXMLEncodingAttribute" to 1 (this is the default behavior and the behavior of most parsers). - * If an inconsistency in the encoding is detected, then the return value is "0". */ - /** @} */ - - private: - // these are functions and structures used internally by the XMLNode class (don't bother about them): - - typedef struct XMLNodeDataTag // to allow shallow copy and "intelligent/smart" pointers (automatic delete): - { - XMLCSTR lpszName; // Element name (=NULL if root) - int nChild, // Number of child nodes - nText, // Number of text fields - nClear, // Number of Clear fields (comments) - nAttribute; // Number of attributes - char isDeclaration; // Whether node is an XML declaration - '' - struct XMLNodeDataTag *pParent; // Pointer to parent element (=NULL if root) - XMLNode *pChild; // Array of child nodes - XMLCSTR *pText; // Array of text fields - XMLClear *pClear; // Array of clear fields - XMLAttribute *pAttribute; // Array of attributes - int *pOrder; // order of the child_nodes,text_fields,clear_fields - int ref_count; // for garbage collection (smart pointers) - } XMLNodeData; - XMLNodeData *d; - - char parseClearTag(void *px, void *pa); - char maybeAddTxT(void *pa, XMLCSTR tokenPStr); - int ParseXMLElement(void *pXML); - void *addToOrder(int memInc, int *_pos, int nc, void *p, int size, XMLElementType xtype); - int indexText(XMLCSTR lpszValue) const; - int indexClear(XMLCSTR lpszValue) const; - XMLNode addChild_priv(int,XMLSTR,char,int); - XMLAttribute *addAttribute_priv(int,XMLSTR,XMLSTR); - XMLCSTR addText_priv(int,XMLSTR,int); - XMLClear *addClear_priv(int,XMLSTR,XMLCSTR,XMLCSTR,int); - void emptyTheNode(char force); - static inline XMLElementPosition findPosition(XMLNodeData *d, int index, XMLElementType xtype); - static int CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat); - static int removeOrderElement(XMLNodeData *d, XMLElementType t, int index); - static void exactMemory(XMLNodeData *d); - static int detachFromParent(XMLNodeData *d); -} XMLNode; - -/// This structure is given by the function XMLNode::enumContents. -typedef struct XMLNodeContents -{ - /// This dictates what's the content of the XMLNodeContent - enum XMLElementType etype; - /**< should be an union to access the appropriate data. Compiler does not allow union of object with constructor... too bad. */ - XMLNode child; - XMLAttribute attrib; - XMLCSTR text; - XMLClear clear; - -} XMLNodeContents; - -/** @defgroup StringAlloc String Allocation/Free functions - * @ingroup xmlModify - * @{ */ -/// Duplicate (copy in a new allocated buffer) the source string. -XMLDLLENTRY XMLSTR stringDup(XMLCSTR source, int cbData=-1); -/**< This is - * a very handy function when used with all the "XMLNode::*_WOSD" functions (\link xmlWOSD \endlink). - * @param cbData If !=0 then cbData is the number of chars to duplicate. New strings allocated with - * this function should be free'd using the "freeXMLString" function. */ - -/// to free the string allocated inside the "stringDup" function or the "createXMLString" function. -XMLDLLENTRY void freeXMLString(XMLSTR t); // {free(t);} -/** @} */ - -/** @defgroup atoX ato? like functions - * @ingroup XMLParserGeneral - * The "xmlto?" functions are equivalents to the atoi, atol, atof functions. - * The only difference is: If the variable "xmlString" is NULL, than the return value - * is "defautValue". These 6 functions are only here as "convenience" functions for the - * user (they are not used inside the XMLparser). If you don't need them, you can - * delete them without any trouble. - * - * @{ */ -XMLDLLENTRY char xmltob(XMLCSTR xmlString,char defautValue=0); -XMLDLLENTRY int xmltoi(XMLCSTR xmlString,int defautValue=0); -XMLDLLENTRY long long xmltol(XMLCSTR xmlString,long long defautValue=0); -XMLDLLENTRY double xmltof(XMLCSTR xmlString,double defautValue=.0); -XMLDLLENTRY XMLCSTR xmltoa(XMLCSTR xmlString,XMLCSTR defautValue=_CXML("")); -XMLDLLENTRY XMLCHAR xmltoc(XMLCSTR xmlString,const XMLCHAR defautValue=_CXML('\0')); -/** @} */ - -/** @defgroup ToXMLStringTool Helper class to create XML files using "printf", "fprintf", "cout",... functions. - * @ingroup XMLParserGeneral - * @{ */ -/// Helper class to create XML files using "printf", "fprintf", "cout",... functions. -/** The ToXMLStringTool class helps you creating XML files using "printf", "fprintf", "cout",... functions. - * The "ToXMLStringTool" class is processing strings so that all the characters - * &,",',<,> are replaced by their XML equivalent: - * \verbatim &, ", ', <, > \endverbatim - * Using the "ToXMLStringTool class" and the "fprintf function" is THE most efficient - * way to produce VERY large XML documents VERY fast. - * \note If you are creating from scratch an XML file using the provided XMLNode class - * you must not use the "ToXMLStringTool" class (because the "XMLNode" class does the - * processing job for you during rendering).*/ -typedef struct XMLDLLENTRY ToXMLStringTool -{ -public: - ToXMLStringTool(): buf(NULL),buflen(0){} - ~ToXMLStringTool(); - void freeBuffer();///