loginserver接收登陆网关注册登陆数据,存入数据库

根据代码分析,登录网关数据的接收和处理流程如下: 网关连接建立: procedure TFrmMain.GSocketClientConnect(Sender: TObject; Socket: TCustomWinSocket); begin // 创建新的网关信息结构 New(GateInfo);...

meinvwudi · 2024-12-11T03:51:06+00:00

根据代码分析,登录网关数据的接收和处理流程如下: 网关连接建立: procedure TFrmMain.GSocketClientConnect(Sender: TObject; Socket: TCustomWinSocket); begin // 创建新的网关信息结构 New(GateInfo);...

loginserver接收登陆网关注册登陆数据,存入数据库

meinvwudi

根据代码分析,登录网关数据的接收和处理流程如下:

网关连接建立:
```
procedure TFrmMain.GSocketClientConnect(Sender: TObject; Socket: TCustomWinSocket);
begin
  // 创建新的网关信息结构
  New(GateInfo);
  GateInfo.Socket := Socket;
  GateInfo.sIPaddr := GetGatePublicAddr(Config, Socket.RemoteAddress);
  GateInfo.UserList := TList.Create;
  
  // 添加到网关列表
  Config.GateList.Add(GateInfo);
end
```
1. 接收网关数据:
```
procedure TFrmMain.GSocketClientRead(Sender: TObject; Socket: TCustomWinSocket);
begin
  // 将接收到的数据追加到网关的接收缓冲区
  GateInfo.sReceiveMsg := GateInfo.sReceiveMsg + Socket.ReceiveText;
end
```
2. 处理登录请求:
```
procedure AccountLogin(Config: pTConfig; UserInfo: pTUserInfo; sData: string);
begin
  // 解析登录ID和密码
  sPassword := GetValidStr3(DecodeString(sData), sLoginID, ['/']);
  
  // 打开账号数据库验证
  if AccountDB.Open then begin
    n10 := AccountDB.Index(sLoginID);
    if AccountDB.Get(n10, DBRecord) >= 0 then begin
      // 验证密码
      if DBRecord.UserEntry.sPassword = sPassword then begin
        // 登录成功
        UserInfo.sAccount := sLoginID;
        UserInfo.nSessionID := GetSessionID();
        
        // 添加会话信息
        SessionAdd(Config, UserInfo.sAccount, UserInfo.sUserIPaddr,
          UserInfo.sServerName, UserInfo.nSessionID, UserInfo.boPayCost, False);
          
        // 发送登录成功消息给客户端
        SendGateMsg(UserInfo.Socket, UserInfo.sSockIndex, ...);
      end;
    end;
  end;
end
```
  1. 主要数据结构:
```
// 网关信息
TGateInfo = record
  Socket: TCustomWinSocket;
  sIPaddr: string;
  sReceiveMsg: string; 
  UserList: TList;
end;

// 用户信息
TUserInfo = record
  sAccount: string;
  sUserIPaddr: string;
  nSessionID: Integer;
  Socket: TCustomWinSocket;
  // ...
end;
```
  主要流程是:
  1. 网关连接后创建 GateInfo 结构保存连接信息
  2. 接收网关发来的数据存入接收缓冲区
  3. 解析登录请求,验证账号密码
  4. 验证成功后:
  5. 创建会话信息
  6. 写入数据库
  7. 返回登录成功消息给客户端
  8. 所有数据都通过 AccountDB 写入到数据库文件中保存
  这样实现了登录网关数据的接收和数据库存储功能。

meinvwudi

让我详细分析一下数据库写入的相关代码：

数据库初始化：
```
procedure TFrmMain.StartTimerTimer(Sender: TObject);
begin
  // 创建数据库对象,打开ID.DB文件
  AccountDB := TFileIDDB.Create(Config.sIdDir + 'Id.DB');
end
```
账号创建时写入数据库：
```
procedure AccountCreate(Config: pTConfig; Msg: pTDefaultMessage; UserInfo: pTUserInfo; sData: string);
var
  DBRecord: TAccountDBRecord;
  nIndex: Integer;
begin
  try
    if AccountDB.Open then begin
      // 检查账号是否已存在
      nIndex := AccountDB.Index(UserEntry.sAccount);
      if nIndex < 0 then begin  // 账号不存在
        // 初始化数据库记录
        DBRecord.UserEntry := UserEntry;
        DBRecord.UserEntryAdd := UserAddEntry;
        DBRecord.nErrorCount := 0;
        DBRecord.dwActionTick := 0;
        
        // 添加新记录到数据库
        if AccountDB.Add(DBRecord) >= 0 then begin
          // 写入日志
          WriteLogMsg(Config, 'new', UserEntry, UserAddEntry);
          nCode := 1;  // 创建成功
        end;
      end;
    end;
  finally
    AccountDB.Close;  // 关闭数据库
  end;
end
```
1. 更新账号信息：
```
procedure AccountUpdateUserInfo(Config: pTConfig; UserInfo: pTUserInfo; sData: string);
begin
  try
    if AccountDB.Open then begin
      // 查找账号索引
      n10 := AccountDB.Index(UserEntry.sAccount);
      if (n10 >= 0) then begin
        // 读取现有记录
        if (AccountDB.Get(n10, DBRecord) >= 0) then begin
          // 更新记录内容
          DBRecord.UserEntry := UserEntry;
          DBRecord.UserEntryAdd := UserAddEntry;
          // 写回数据库
          AccountDB.Update(n10, DBRecord);
          nCode := 1;
        end;
      end;
    end;
  finally
    AccountDB.Close;
  end;
end
```
2. 数据库记录结构：
```
TUserEntry = record
  sAccount: string;    // 账号
  sPassword: string;   // 密码  
  sUserName: string;   // 用户名
  sSSNo: string;      // 身份证号
  sQuiz: string;      // 密保问题
  sAnswer: string;    // 密保答案
  sEMail: string;     // 邮箱
end;

TUserEntryAdd = record
  sQuiz2: string;     // 密保问题2
  sAnswer2: string;   // 密保答案2  
  sBirthDay: string;  // 生日
  sMobilePhone: string; // 手机号
end;

TAccountDBRecord = record
  UserEntry: TUserEntry;      // 基本信息
  UserEntryAdd: TUserEntryAdd; // 附加信息
  nErrorCount: Integer;       // 错误计数
  dwActionTick: LongWord;     // 操作时间戳
end;
```
  主要操作流程：
  1. 打开数据库文件：AccountDB.Open
  2. 数据库操作：
  3. 添加记录：AccountDB.Add
  4. 更新记录：AccountDB.Update
  5. 读取记录：AccountDB.Get
  6. 查找索引：AccountDB.Index
  7. 关闭数据库：AccountDB.Close
  8. 写入日志：WriteLogMsg 记录操作日志
  数据库使用 TFileIDDB 类实现，是一个基于文件的简单数据库系统：
  - 以账号为索引
  - 记录固定长度
  - 支持添加、删除、修改、查询等基本操作
  - 使用文件锁保证并发安全
  这样实现了账号数据的持久化存储。每次账号创建、修改等操作都会同步到数据库文件中。

meinvwudi

让我分析一下 AccountDB.Add 的实现原理。这个方法在 IDDB.pas 中实现：

type
  TFileIDDB = class
  private
    m_nLastIndex: Integer;
    m_nDeletedPosition: Integer;
    m_Header: TDBHeader;
    m_nFileHandle: Integer;
    // ...
  end;

procedure TFileIDDB.Add(var DBRecord: TAccountDBRecord): Integer;
var
  nFilePos: Integer;
begin
  Result := -1;
  if not m_boOpened then Exit;
  
  EnterCriticalSection(m_cs);
  try
    // 1. 先检查是否有被删除的空位可以重用
    if m_nDeletedPosition > 0 then begin
      // 获取被删除记录的位置
      nFilePos := m_nDeletedPosition;
      
      // 读取下一个被删除记录的位置(链表结构)
      FileSeek(m_nFileHandle, nFilePos, 0);
      FileRead(m_nFileHandle, m_nDeletedPosition, SizeOf(Integer));
      
      // 将新记录写入这个位置
      FileSeek(m_nFileHandle, nFilePos, 0);
      FileWrite(m_nFileHandle, DBRecord, SizeOf(TAccountDBRecord));
      
      Result := nFilePos;
    end else begin
      // 2. 没有可重用的空位,追加到文件末尾
      
      // 定位到文件末尾
      nFilePos := FileSeek(m_nFileHandle, 0, 2); 
      
      // 写入新记录
      FileWrite(m_nFileHandle, DBRecord, SizeOf(TAccountDBRecord));
      
      // 更新最后一条记录的索引
      Inc(m_nLastIndex);
      
      // 更新文件头信息
      FileSeek(m_nFileHandle, 0, 0);
      m_Header.nLastIndex := m_nLastIndex;
      FileWrite(m_nFileHandle, m_Header, SizeOf(TDBHeader));
      
      Result := nFilePos;
    end;

    // 3. 更新索引表
    UpdateIndex(DBRecord.UserEntry.sAccount, nFilePos);
    
  finally
    LeaveCriticalSection(m_cs);
  end;
end;

主要实现原理：

文件结构：
```
[文件头信息(TDBHeader)] + [记录数据区] + [索引区]
```
记录存储采用两种方式：
重用已删除记录的空间(通过删除链表维护)
追加到文件末尾
索引机制：
```
procedure TFileIDDB.UpdateIndex(sName: string; nPosition: Integer);
begin
  // 使用哈希表存储账号名到文件位置的映射
  m_IndexList.AddObject(sName, TObject(nPosition));
end;
```
文件操作流程：

graph TD
    A[开始添加记录] --> B{有删除空位?}
    B -->|是| C[重用删除空位]
    B -->|否| D[追加到文件末尾]
    C --> E[更新删除链表]
    D --> F[更新文件头]
    E --> G[更新索引表]
    F --> G
    G --> H[结束]

关键数据结构：

// 文件头
TDBHeader = record
  sDesc: string[16];     // 描述信息
  nLastIndex: Integer;   // 最后记录索引
  nDeletedIndex: Integer;// 第一个被删除记录位置
end;

// 记录结构
TAccountDBRecord = record
  UserEntry: TUserEntry;      // 基本信息
  UserEntryAdd: TUserEntryAdd;// 扩展信息
  nErrorCount: Integer;       // 错误计数
  dwActionTick: LongWord;     // 时间戳
end;

并发控制：
使用临界区(CriticalSection)保护文件操作
文件锁确保多进程安全
性能优化：
索引表加速查找
空间重用减少文件碎片
批量读写减少IO次数

这种实现方式的特点：

优点：

结构简单,易于实现
支持记录重用
查找效率较高(通过索引)

缺点：

不支持事务
文件可能产生碎片
并发性能有限

这是一个典型的基于文件的简单数据库实现,适合于小型应用的数据存储需求。

meinvwudi

让我分析一下 AccountDB.Add 的实现原理。这个方法在 IDDB.pas 中实现：

type
  TFileIDDB = class
  private
    m_nLastIndex: Integer;
    m_nDeletedPosition: Integer;
    m_Header: TDBHeader;
    m_nFileHandle: Integer;
    // ...
  end;

procedure TFileIDDB.Add(var DBRecord: TAccountDBRecord): Integer;
var
  nFilePos: Integer;
begin
  Result := -1;
  if not m_boOpened then Exit;
  
  EnterCriticalSection(m_cs);
  try
    // 1. 先检查是否有被删除的空位可以重用
    if m_nDeletedPosition > 0 then begin
      // 获取被删除记录的位置
      nFilePos := m_nDeletedPosition;
      
      // 读取下一个被删除记录的位置(链表结构)
      FileSeek(m_nFileHandle, nFilePos, 0);
      FileRead(m_nFileHandle, m_nDeletedPosition, SizeOf(Integer));
      
      // 将新记录写入这个位置
      FileSeek(m_nFileHandle, nFilePos, 0);
      FileWrite(m_nFileHandle, DBRecord, SizeOf(TAccountDBRecord));
      
      Result := nFilePos;
    end else begin
      // 2. 没有可重用的空位,追加到文件末尾
      
      // 定位到文件末尾
      nFilePos := FileSeek(m_nFileHandle, 0, 2); 
      
      // 写入新记录
      FileWrite(m_nFileHandle, DBRecord, SizeOf(TAccountDBRecord));
      
      // 更新最后一条记录的索引
      Inc(m_nLastIndex);
      
      // 更新文件头信息
      FileSeek(m_nFileHandle, 0, 0);
      m_Header.nLastIndex := m_nLastIndex;
      FileWrite(m_nFileHandle, m_Header, SizeOf(TDBHeader));
      
      Result := nFilePos;
    end;

    // 3. 更新索引表
    UpdateIndex(DBRecord.UserEntry.sAccount, nFilePos);
    
  finally
    LeaveCriticalSection(m_cs);
  end;
end;

主要实现原理：

文件结构：
```
[文件头信息(TDBHeader)] + [记录数据区] + [索引区]
```
记录存储采用两种方式：
重用已删除记录的空间(通过删除链表维护)
追加到文件末尾
索引机制：
```
procedure TFileIDDB.UpdateIndex(sName: string; nPosition: Integer);
begin
  // 使用哈希表存储账号名到文件位置的映射
  m_IndexList.AddObject(sName, TObject(nPosition));
end;
```
文件操作流程：

graph TD
    A[开始添加记录] --> B{有删除空位?}
    B -->|是| C[重用删除空位]
    B -->|否| D[追加到文件末尾]
    C --> E[更新删除链表]
    D --> F[更新文件头]
    E --> G[更新索引表]
    F --> G
    G --> H[结束]

关键数据结构：

// 文件头
TDBHeader = record
  sDesc: string[16];     // 描述信息
  nLastIndex: Integer;   // 最后记录索引
  nDeletedIndex: Integer;// 第一个被删除记录位置
end;

// 记录结构
TAccountDBRecord = record
  UserEntry: TUserEntry;      // 基本信息
  UserEntryAdd: TUserEntryAdd;// 扩展信息
  nErrorCount: Integer;       // 错误计数
  dwActionTick: LongWord;     // 时间戳
end;

并发控制：
使用临界区(CriticalSection)保护文件操作
文件锁确保多进程安全
性能优化：
索引表加速查找
空间重用减少文件碎片
批量读写减少IO次数

这种实现方式的特点：

优点：

结构简单,易于实现
支持记录重用
查找效率较高(通过索引)

缺点：

不支持事务
文件可能产生碎片
并发性能有限

这是一个典型的基于文件的简单数据库实现,适合于小型应用的数据存储需求。

meinvwudi

是的,Python 也可以实现类似的记录结构。我来展示几种实现方式:

使用 struct 模块实现固定长度记录:

import struct
from dataclasses import dataclass
from typing import List
import os

# 定义记录结构
@dataclass
class UserEntry:
    account: str    # 账号
    password: str   # 密码
    username: str   # 用户名
    ssno: str      # 身份证
    quiz: str      # 密保问题 
    answer: str    # 密保答案
    email: str     # 邮箱

@dataclass 
class UserEntryAdd:
    quiz2: str         # 密保问题2
    answer2: str       # 密保答案2
    birthday: str      # 生日
    mobile_phone: str  # 手机

@dataclass
class AccountDBRecord:
    user_entry: UserEntry
    user_entry_add: UserEntryAdd
    error_count: int
    action_tick: int

class FileIDDB:
    # 文件头格式
    HEADER_FORMAT = "16sii"  # desc(16字节) + last_index(4字节) + deleted_index(4字节)
    # 记录格式(每个字符串字段用32字节存储)
    RECORD_FORMAT = "32s32s32s32s32s32s32s32s32s32s32sii"
    
    def __init__(self, filename: str):
        self.filename = filename
        self.header_size = struct.calcsize(self.HEADER_FORMAT)
        self.record_size = struct.calcsize(self.RECORD_FORMAT)
        self.index_map = {}  # 账号->文件位置的映射
        
    def open(self):
        """打开或创建数据库文件"""
        if not os.path.exists(self.filename):
            # 创建新文件
            with open(self.filename, "wb") as f:
                # 写入文件头
                header = struct.pack(self.HEADER_FORMAT, 
                    b"ACCOUNT_DB", 0, 0)
                f.write(header)
        self._load_index()
        
    def _load_index(self):
        """加载索引"""
        self.index_map.clear()
        with open(self.filename, "rb") as f:
            # 跳过文件头
            f.seek(self.header_size)
            
            while True:
                # 读取记录
                data = f.read(self.record_size)
                if not data:
                    break
                    
                # 解析记录
                record = self._unpack_record(data)
                if record:
                    # 建立索引映射
                    pos = f.tell() - self.record_size
                    self.index_map[record.user_entry.account] = pos
                    
    def add(self, record: AccountDBRecord) -> int:
        """添加记录"""
        with open(self.filename, "r+b") as f:
            # 1. 检查是否有删除空位可用
            header = self._read_header(f)
            if header.deleted_index > 0:
                # 使用删除空位
                pos = header.deleted_index
                f.seek(pos)
                # 读取下一个删除位置
                next_del = struct.unpack("i", f.read(4))[0]
                # 更新文件头
                header.deleted_index = next_del
                self._write_header(f, header)
            else:
                # 追加到文件末尾
                f.seek(0, 2)  # 移到文件末尾
                pos = f.tell()
                header.last_index += 1
                self._write_header(f, header)
                
            # 2. 写入记录
            f.seek(pos)
            data = self._pack_record(record)
            f.write(data)
            
            # 3. 更新索引
            self.index_map[record.user_entry.account] = pos
            
            return pos
            
    def _pack_record(self, record: AccountDBRecord) -> bytes:
        """将记录打包为字节串"""
        return struct.pack(self.RECORD_FORMAT,
            record.user_entry.account.encode(),
            record.user_entry.password.encode(),
            record.user_entry.username.encode(),
            record.user_entry.ssno.encode(),
            record.user_entry.quiz.encode(),
            record.user_entry.answer.encode(), 
            record.user_entry.email.encode(),
            record.user_entry_add.quiz2.encode(),
            record.user_entry_add.answer2.encode(),
            record.user_entry_add.birthday.encode(),
            record.user_entry_add.mobile_phone.encode(),
            record.error_count,
            record.action_tick
        )
        
    def _unpack_record(self, data: bytes) -> AccountDBRecord:
        """将字节串解包为记录"""
        fields = struct.unpack(self.RECORD_FORMAT, data)
        
        # 解码字符串字段
        account = fields[0].decode().rstrip('\0')
        password = fields[1].decode().rstrip('\0')
        username = fields[2].decode().rstrip('\0')
        ssno = fields[3].decode().rstrip('\0')
        quiz = fields[4].decode().rstrip('\0')
        answer = fields[5].decode().rstrip('\0')
        email = fields[6].decode().rstrip('\0')
        quiz2 = fields[7].decode().rstrip('\0')
        answer2 = fields[8].decode().rstrip('\0')
        birthday = fields[9].decode().rstrip('\0')
        mobile = fields[10].decode().rstrip('\0')
        
        user_entry = UserEntry(
            account=account,
            password=password,
            username=username,
            ssno=ssno,
            quiz=quiz,
            answer=answer,
            email=email
        )
        
        user_entry_add = UserEntryAdd(
            quiz2=quiz2,
            answer2=answer2, 
            birthday=birthday,
            mobile_phone=mobile
        )
        
        return AccountDBRecord(
            user_entry=user_entry,
            user_entry_add=user_entry_add,
            error_count=fields[11],
            action_tick=fields[12]
        )

使用示例:

# 创建数据库
db = FileIDDB("accounts.db")
db.open()

# 添加记录
record = AccountDBRecord(
    user_entry=UserEntry(
        account="test1",
        password="123456",
        username="Test User",
        ssno="123456789",
        quiz="Your pet name?",
        answer="dog",
        email="test@test.com"
    ),
    user_entry_add=UserEntryAdd(
        quiz2="Your city?",
        answer2="Beijing",
        birthday="1990-01-01",
        mobile_phone="13800138000"
    ),
    error_count=0,
    action_tick=0
)

pos = db.add(record)
print(f"Record added at position: {pos}")

使用 SQLite 实现(更简单的方案):

import sqlite3
from dataclasses import dataclass
import time

class AccountDB:
    def __init__(self, db_file: str):
        self.db_file = db_file
        self.conn = None
        
    def open(self):
        self.conn = sqlite3.connect(self.db_file)
        self._create_tables()
        
    def _create_tables(self):
        """创建数据表"""
        cur = self.conn.cursor()
        cur.execute('''
        CREATE TABLE IF NOT EXISTS accounts (
            account TEXT PRIMARY KEY,
            password TEXT,
            username TEXT,
            ssno TEXT,
            quiz TEXT,
            answer TEXT,
            email TEXT,
            quiz2 TEXT,
            answer2 TEXT,
            birthday TEXT,
            mobile_phone TEXT,
            error_count INTEGER,
            action_tick INTEGER
        )
        ''')
        self.conn.commit()
        
    def add(self, record: AccountDBRecord):
        """添加记录"""
        cur = self.conn.cursor()
        cur.execute('''
        INSERT INTO accounts VALUES (
            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
        )
        ''', (
            record.user_entry.account,
            record.user_entry.password,
            record.user_entry.username,
            record.user_entry.ssno,
            record.user_entry.quiz,
            record.user_entry.answer,
            record.user_entry.email,
            record.user_entry_add.quiz2,
            record.user_entry_add.answer2,
            record.user_entry_add.birthday,
            record.user_entry_add.mobile_phone,
            record.error_count,
            record.action_tick
        ))
        self.conn.commit()

两种方案比较:

struct 方案:
优点:
- 完全控制文件格式
- 固定长度记录,读写快速
- 支持记录重用
缺点:
- 需要自己处理索引
- 需要处理字符编码
- 代码较复杂
SQLite 方案:
优点:
- 实现简单
- 自动索引
- 支持SQL查询
- 事务支持
缺点:
- 文件格式固定
- 可能比直接文件操作慢

根据实际需求选择合适的方案:

如果需要完全控制文件格式,用 struct 方案
如果追求开发效率,用 SQLite 方案

meinvwudi

让我分析一下登录网关启动时的监听流程：

启动服务和监听：
```
procedure TFrmMain.StartTimerTimer(Sender: TObject);
var
  Config: pTConfig;
begin
  StartTimer.Enabled := False;
  Config := @g_Config;
  
  // 1. 初始化数据库
  AccountDB := TFileIDDB.Create(Config.sIdDir + 'Id.DB');
  
  // 2. 启动消息解析线程
  ParseList.Resume;
  
  // 3. 等待服务器连接就绪
  while (True) do begin
    if FrmMasSoc.CheckReadyServers then Break;
    Sleep(1);
  end;
  
  // 4. 启动网关监听
  GSocket.Active := False;
  GSocket.Address := Config.sGateAddr;  // 监听地址
  GSocket.Port := Config.nGatePort;     // 监听端口
  GSocket.Active := True;               // 开始监听
  
  // 5. 启动主循环定时器
  ExecTimer.Enabled := True;
end;
```
1. 网络消息处理流程：
```
// 主循环处理网关消息
procedure TFrmMain.ExecTimerTimer(Sender: TObject);
begin
  Config := @g_Config;
  try
    ProcessGate(Config); // 处理网关消息
  finally
    bo470D20 := False;
  end;
end;

// 处理网关消息
procedure ProcessGate(Config: pTConfig);
begin
  EnterCriticalSection(Config.GateCriticalSection);
  try
    for I := 0 to Config.GateList.Count - 1 do begin
      GateInfo := Config.GateList.Items[I];
      
      // 1. 处理网关缓冲区数据
      if GateInfo.sReceiveMsg <> '' then begin
        DecodeGateData(Config, GateInfo);
        
        // 2. 处理每个用户的消息
        for II := 0 to GateInfo.UserList.Count - 1 do begin
          UserInfo := GateInfo.UserList.Items[II];
          if UserInfo.sReceiveMsg <> '' then 
            DecodeUserData(Config, UserInfo);
        end;
      end;
    end;
  finally
    LeaveCriticalSection(Config.GateCriticalSection);
  end;
end;
```
1. 消息解析和处理：
```
// 解析用户数据
procedure DecodeUserData(Config: pTConfig; UserInfo: pTUserInfo);
var
  sMsg: string; 
  DefMsg: TDefaultMessage;
begin
  while (True) do begin
    if not DecodeMessage(UserInfo.sReceiveMsg, sMsg) then Break;
    
    // 解析消息头
    DefMsg := DecodeMessage(sMsg);
    
    // 根据消息类型处理
    case DefMsg.Ident of
      CM_ADDNEWUSER: // 创建账号
        AccountCreate(Config, @DefMsg, UserInfo, sMsg);
        
      CM_UPDATEUSER: // 更新账号
        AccountUpdateUserInfo(Config, UserInfo, sMsg);
        
      CM_CHANGEPASSWORD: // 修改密码  
        AccountChangePassword(Config, UserInfo, sMsg);
        
      CM_IDPASSWORD: // 登录验证
        AccountLogin(Config, UserInfo, sMsg);
        
      CM_SELECTSERVER: // 选择服务器
        AccountSelectServer(Config, UserInfo, sMsg);
    end;
  end;
end;
```
1. 账号创建处理：
```
procedure AccountCreate(Config: pTConfig; Msg: pTDefaultMessage; UserInfo: pTUserInfo; sData: string);
var
  nCode: Integer;
  DefMsg: TDefaultMessage;
begin
  try
    // 1. 解析账号数据
    DecodeBuffer(sUserEntryMsg, @UserEntry, SizeOf(TUserEntry));
    DecodeBuffer(sUserAddEntryMsg, @UserAddEntry, SizeOf(TUserEntryAdd));

    // 2. 验证账号格式
    if CheckAccountName(UserEntry.sAccount) then begin
      // 3. 写入数据库
      if AccountDB.Open then begin
        if AccountDB.Add(DBRecord) >= 0 then begin
          // 写入成功
          WriteLogMsg(Config, 'new', UserEntry, UserAddEntry);
          nCode := 1;
        end;
      end;
    end;

    // 4. 返回结果给客户端
    if nCode = 1 then begin
      DefMsg := MakeDefaultMsg(SM_NEWID_SUCCESS, 0, 0, 0, 0);
    end else begin
      DefMsg := MakeDefaultMsg(SM_NEWID_FAIL, nCode, 0, 0, 0); 
    end;
    SendGateMsg(UserInfo.Socket, UserInfo.sSockIndex, EncodeMessage(DefMsg));
  end;
end;
```
1. 账号更新处理：
```
procedure AccountUpdateUserInfo(Config: pTConfig; UserInfo: pTUserInfo; sData: string);
begin
  try
    // 1. 解析更新数据
    DecodeBuffer(sUserEntryMsg, @UserEntry, SizeOf(TUserEntry));
    DecodeBuffer(sUserAddEntryMsg, @UserAddEntry, SizeOf(TUserEntryAdd));

    // 2. 更新数据库
    if AccountDB.Open then begin
      if AccountDB.Update(nIndex, DBRecord) >= 0 then begin
        WriteLogMsg(Config, 'upd', UserEntry, UserAddEntry);
        nCode := 1;
      end;
    end;

    // 3. 返回结果
    if nCode = 1 then
      DefMsg := MakeDefaultMsg(SM_UPDATEID_SUCCESS, 0, 0, 0, 0)
    else 
      DefMsg := MakeDefaultMsg(SM_UPDATEID_FAIL, nCode, 0, 0, 0);
      
    SendGateMsg(UserInfo.Socket, UserInfo.sSockIndex, EncodeMessage(DefMsg));
  end;
end;
```
主要流程：
```
graph TD
    A[启动服务] --> B[初始化数据库]
    B --> C[启动消息解析线程]
    C --> D[开始网关监听]
    D --> E[主循环处理消息]
    E --> F{消息类型}
    F -->|创建账号| G[AccountCreate]
    F -->|更新账号| H[AccountUpdate]
    F -->|修改密码| I[ChangePassword]
    F -->|登录验证| J[AccountLogin]
    F -->|选服务器| K[SelectServer]
```
关键点：
1. 使用 GSocket 组件监听网关连接
2. ExecTimer 定时器循环处理消息
3. 消息采用头部标识区分类型
4. 使用临界区保护并发访问
5. 所有操作都记录日志
6. 统一的消息编码解码机制
这样实现了一个完整的登录网关消息处理系统。