登陆网关接收客户端消息和发送到loginserver

meinvwudi

让我用中文为您分析这段代码的主要工作原理:

这是一个登录网关服务器的核心代码,主要负责:

连接管理
```
TUserEngine类负责:
- 管理客户端连接(ServerSocket)
- 与账号服务器的连接(ClientSocket) 
- 维护用户连接列表(m_UserList)
```
消息转发
```
主要流程:
- 客户端 -> 网关 -> 账号服务器
- 账号服务器 -> 网关 -> 客户端

通过:
- ServerSocketClientRead() 接收客户端消息
- ClientSocketRead() 接收账号服务器消息
- SendServerMsg() 发送到账号服务器
- SendClientMsg() 发送到客户端
```
安全防护
```
主要防护:
- CC攻击检测(UpdateCCAttackIPList)
- IP黑名单(BlockIPList) 
- 消息长度检查
- 消息频率检查
- 单IP最大连接数限制
```
连接状态维护
```
- 心跳包检测(KeepAlive)
- 超时断开
- 空闲连接清理
- 异常连接处理
```
关键数据结构
```
TUserObject: 单个用户连接对象
- m_Socket: 套接字
- m_SendMsgList: 发送消息队列
- m_ReviceMsgList: 接收消息队列

TUserEngine: 
- m_UserList: 在线用户列表
- m_BlockIPList: 黑名单列表
- m_CCAttackIPList: CC攻击IP列表
```
这是一个典型的游戏登录网关架构,通过消息转发和安全防护,实现了客户端与账号服务器之间的安全通信。

需要注意的关键点:
1. 使用了临界区(Critical Section)保证线程安全
2. 采用消息队列缓存收发的消息
3. 实现了多重安全检查机制
4. 使用心跳包保持连接状态
5. 具有完善的异常处理机制

meinvwudi

我来为这些关键方法添加详细的中文注释:

// 处理客户端连接事件
procedure TUserEngine.ServerSocketClientConnect(Socket: TCustomWinSocket);
var
  sRemoteIPaddr: string;
  UserObject: TUserObject;
begin
  if m_boStartService then begin  // 服务已启动才处理连接
    MemLock;  // 内存锁定,防止多线程访问冲突
    try
      // 创建新的用户对象并初始化
      sRemoteIPaddr := Socket.RemoteAddress;  // 获取客户端IP
      UserObject := TUserObject.Create;       // 创建用户对象
      UserObject.m_sRemoteIPaddr := sRemoteIPaddr;  // 设置IP地址
      UserObject.m_Socket := Socket;          // 关联Socket
      Socket.nIndex := Integer(UserObject);   // Socket绑定用户对象引用
    finally
      MemUnLock;  // 释放内存锁
    end;

    Lock;  // 用户列表锁定
    try
      // 将用户添加到在线列表
      m_UserList.AddObject(sRemoteIPaddr, UserObject);      // 添加到用户列表
      m_QuickUserList.AddRecord(sRemoteIPaddr, UserObject); // 添加到快速查找列表
    finally
      UnLock;  // 释放列表锁
    end;
  end else begin
    Socket.Close;  // 服务未启动则关闭连接
  end;
end;

// 处理客户端断开连接事件
procedure TUserEngine.ServerSocketClientDisconnect(Socket: TCustomWinSocket);
var
  UserObject: TUserObject;
begin
  if m_boStartService then begin  // 服务运行中才处理
    UserObject := TUserObject(Socket.nIndex);  // 获取关联的用户对象
    if (UserObject <> nil) then begin
      UserObject.Lock;  // 锁定用户对象
      try
        // 清理用户对象相关引用
        UserObject.m_Socket := nil;        // 清除Socket引用
        Socket.nIndex := 0;                // 清除Socket关联
        UserObject.m_boDisconnect := True; // 标记断开状态
      finally
        UserObject.UnLock;  // 释放用户对象锁
      end;
    end;
  end;
end;

// 处理Socket错误事件
procedure TUserEngine.ServerSocketClientError(Socket: TCustomWinSocket;
  ErrorEvent: TErrorEvent; var ErrorCode: Integer);
begin
  ErrorCode := 0;      // 清除错误码
  Socket.Close;        // 关闭问题Socket
end;

// 处理客户端消息接收事件
procedure TUserEngine.ServerSocketClientRead(Socket: TCustomWinSocket);
var
  UserObject: TUserObject;
  sReviceMsg: string;
  nMsgCount: Integer;
  dwLastReviceTick: LongWord;
  boAddReviceMsg, boCloseSocket: Boolean;
  AObject: TObject;
begin
  if m_boStartService then begin  // 服务运行中才处理
    boAddReviceMsg := False;
    boCloseSocket := False;
    UserObject := TUserObject(Socket.nIndex);  // 获取用户对象
    
    // 检查用户对象有效性
    if (UserObject <> nil) and (not UserObject.m_boDisconnect) then begin
      UserObject.Lock;  // 锁定用户对象
      try
        sReviceMsg := Socket.ReceiveText;  // 接收消息
        if not UserObject.m_boReviceMsg then
          UserObject.m_boReviceMsg := True;
          
        // 攻击检测逻辑
        if m_boCheckAttack then begin
          // 检查1: 消息长度攻击
          if Length(sReviceMsg) > 352 then begin  
            Socket.Close;
            UserObject.m_boDisconnect := True;
            UserObject.m_btAttackType := 1;
            AObject := UpdateBlockIPList(UserObject);
            MainOutMessage('端口攻击: ' + UserObject.m_sRemoteIPaddr, AObject);
          end else begin
            // 检查2: 消息分隔符攻击
            nMsgCount := TagCount(sReviceMsg, '!');
            if nMsgCount > 1 then begin
              Socket.Close;
              UserObject.m_boDisconnect := True;
              UserObject.m_btAttackType := 2;
              UpdateBlockIPList(UserObject);
            end else begin
              // 检查3: 消息频率攻击
              if UserObject.m_ReviceMsgList.Count >= 5 then begin
                dwLastReviceTick := LongWord(UserObject.m_ReviceMsgList.Objects[UserObject.m_ReviceMsgList.Count - 1]);
                if GetTickCount - dwLastReviceTick < 100 then begin  // 100ms内超过5条消息
                  Socket.Close;
                  UserObject.m_boDisconnect := True;
                  UserObject.m_btAttackType := 3;
                  AObject := UpdateBlockIPList(UserObject);
                  MainOutMessage('端口攻击: ' + UserObject.m_sRemoteIPaddr, AObject);
                end else begin
                  UserObject.m_ReviceMsgList.AddObject(sReviceMsg, TObject(GetTickCount));
                end;
              end else begin
                UserObject.m_ReviceMsgList.AddObject(sReviceMsg, TObject(GetTickCount));
              end;
            end;
          end;
        end else begin
          // 未开启攻击检测,直接添加消息
          UserObject.m_ReviceMsgList.AddObject(sReviceMsg, TObject(GetTickCount));
        end;
        UserObject.m_dwReviceMsgTick := GetTickCount;  // 更新最后接收时间

      finally
        UserObject.UnLock;  // 释放用户对象锁
      end;
    end;
  end else begin
    Socket.Close;  // 服务未运行则关闭连接
  end;
end;

这些方法实现了:

客户端连接的建立与管理
连接断开的清理工作
错误处理机制
消息接收与攻击检测:
- 消息长度检测
- 消息分隔符检测
- 消息频率检测

整体采用了多重锁机制确保线程安全,并通过黑名单机制防止恶意攻击。

meinvwudi

我来为这段代码添加详细的中文注释:

// 将消息添加到接收队列,并记录接收时间戳
UserObject.m_ReviceMsgList.AddObject(sReviceMsg, TObject(GetTickCount));

// 发送消息到账号服务器的处理方法
procedure TUserObject.SendServerMsg(Socket: TCustomWinSocket); 
var
  dwSendTick: LongWord;    // 发送超时时间点
  sReviceMsg: string;      // 待发送的消息
  s10, s1C: string;        // 消息分段临时变量
  nPos: Integer;           // 分隔符位置
begin
  // 检查是否允许发送状态
  if m_boSendConnect then begin
    // 检查连接状态: 本地Socket和目标Socket都必须有效且已连接
    if (not m_boDisconnect) and (m_Socket <> nil) and (m_Socket.Connected) 
       and (Socket <> nil) and (Socket.Connected) then begin
      
      dwSendTick := GetTickCount + 5;  // 设置5ms的发送时间窗口
      
      while True do begin
        // 超时检查 - 防止单次发送占用太长时间
        if GetTickCount > dwSendTick then Break;  
        // 消息队列为空则退出
        if m_ReviceMsgList.Count <= 0 then Break;
        // 连接已断开则退出
        if m_boDisconnect then Break;
        
        // 获取并移除队列中第一条消息
        sReviceMsg := m_ReviceMsgList.Strings[0];
        m_ReviceMsgList.Delete(0);
        
        // 处理消息中的特殊分隔符'*'
        nPos := Pos('*', sReviceMsg);
        if nPos > 0 then begin
          // 分割并重组消息,去除分隔符
          s10 := Copy(sReviceMsg, 1, nPos - 1);         // 分隔符前部分
          s1C := Copy(sReviceMsg, nPos + 1, Length(sReviceMsg) - nPos); // 分隔符后部分
          sReviceMsg := s10 + s1C;                      // 合并消息
        end;
        
        // 累计发送的消息长度
        Inc(m_nReviceMsgLen, Length(sReviceMsg));
        
        // 发送消息到账号服务器
        // 格式: %D<用户对象ID>/<消息内容>$
        if (Socket <> nil) and Socket.Connected then begin
          Socket.SendText('%D' + IntToStr(Integer(Self)) + '/' + sReviceMsg + '$');
        end;
      end;
    end else begin
      // 连接状态异常,清空消息队列
      m_ReviceMsgList.Clear;
    end;
  end;
end;

这段代码展示了消息队列的两个关键操作:

消息入队:
将接收到的消息添加到队列
同时记录消息的接收时间戳(用于频率检测)
消息出队和发送:
使用时间窗口限制单次发送处理时间
处理消息中的特殊字符
按特定格式转发到账号服务器
统计发送的消息总长度
异常情况下清空队列

整体设计考虑了:

超时控制
连接状态检查
消息格式处理
异常处理机制

meinvwudi

是的,注册账号的消息也是通过这个机制发送的。让我详细解释一下:

消息格式处理:
```
// 原始消息可能格式如: "NewAccount*username/password"
nPos := Pos('*', sReviceMsg);
if nPos > 0 then begin
  s10 := Copy(sReviceMsg, 1, nPos - 1);     // s10 = "NewAccount"
  s1C := Copy(sReviceMsg, nPos + 1, Length(sReviceMsg) - nPos); // s1C = "username/password" 
  sReviceMsg := s10 + s1C;                  // 最终消息 = "NewAccountusername/password"
end;
```
发送到账号服务器:
```
// 最终发送格式: %D<用户ID>/NewAccountusername/password$
Socket.SendText('%D' + IntToStr(Integer(Self)) + '/' + sReviceMsg + '$');
```

这里的关键点是:

客户端发送注册请求时会带上特定标识(如"NewAccount")
网关服务器:
- 接收客户端消息
- 处理消息格式
- 添加用户ID标识
- 转发给账号服务器
账号服务器:
- 解析消息
- 识别出是注册请求
- 处理注册逻辑
- 返回结果

所以这是一个完整的消息转发流程,不仅处理注册消息,也处理其他类型的账号相关消息。

meinvwudi

在这个系统中，从登录服务器接收消息并转发给客户端主要通过以下流程：

首先接收登录服务器消息:
```
procedure TUserEngine.ClientSocketRead(Sender: TObject; Socket: TCustomWinSocket);
var
  sReceiveText: string;
begin
  if m_boStartService then begin
    sReceiveText := Socket.ReceiveText;
    m_sReceiveText := m_sReceiveText + sReceiveText; // 累积接收的消息
  end;
end;
```
然后在ProcessServerData中处理消息:
```
// 处理从账号服务器收到的消息
if sSocketMsg[1] = '+' then begin
  // ... 其他消息处理 ...
end else begin
  // 解析出目标用户对象ID
  sSocketMsg := GetValidStr3(sSocketMsg, sUserObject, ['/']);
  nUserObject := Str_ToInt(sUserObject, 0);
  
  // 找到对应的用户对象
  UserObject := TUserObject(nUserObject);
  if (UserObject <> nil) and (not UserObject.m_boDisconnect) 
     and (UserObject.m_Socket <> nil) 
     and (UserObject.m_Socket.Connected) then begin
    // 将消息添加到用户的发送队列
    UserObject.m_SendMsgList.Add(sSocketMsg);
  end;
end;
```
1. 最后通过SendClientMsg发送给客户端:
```
procedure TUserObject.SendClientMsg(); //发送到用户
var
  dwSendTick: LongWord;
  sSendMsg: string;
begin
  if m_boSendConnect then begin
    if (not m_boDisconnect) and (m_Socket <> nil) and (m_Socket.Connected) then begin
      dwSendTick := GetTickCount + 5;  // 5ms发送窗口
      while True do begin
        if GetTickCount > dwSendTick then Break; 
        if m_SendMsgList.Count <= 0 then Break;
        if m_boDisconnect then Break;
        
        // 从发送队列取出消息发送给客户端
        sSendMsg := m_SendMsgList.Strings[0];
        m_SendMsgList.Delete(0);
        m_Socket.SendText(sSendMsg);
        Inc(m_nSendMsgLen, Length(sSendMsg));
      end;
    end else begin
      m_SendMsgList.Clear;
    end;
  end;
end;
```
  主要流程是:
  1. 登录服务器返回结果 -> 网关服务器
  2. 网关解析消息,找到对应用户对象
  3. 将消息加入用户的发送队列
  4. SendClientMsg方法定时处理发送队列
  5. 最终发送给客户端
  关键点:
  - 使用消息队列缓存待发送消息
  - 通过用户对象ID关联客户端
  - 设置发送时间窗口控制发送节奏
  - 有完整的连接状态检查

meinvwudi

让我分析一下注册成功时的消息格式:

从登录服务器返回的消息格式大致是:
```
// 登录服务器 -> 网关服务器
'%R' + IntToStr(nUserObject) + '/1/注册成功$'  // 成功
'%R' + IntToStr(nUserObject) + '/0/帐号已存在$' // 失败
```
网关服务器转发给客户端的格式:
```
// 网关服务器 -> 客户端
'#REGT/1/注册成功!'   // 成功
'#REGT/0/帐号已存在!' // 失败
```

其中:

#REGT - 表示这是注册操作的响应
1 或 0 - 表示成功或失败
/ - 消息分隔符
! - 消息结束符

完整的消息处理流程:

// 1. 登录服务器返回结果
'%R1234/1/注册成功$'

// 2. 网关解析并加入发送队列
UserObject.m_SendMsgList.Add('#REGT/1/注册成功!');

// 3. SendClientMsg发送给客户端
m_Socket.SendText('#REGT/1/注册成功!');

客户端收到这个消息后:

解析消息类型(REGT)
检查结果代码(1/0)
显示结果信息
根据成功/失败决定下一步操作

这种消息格式设计的特点:

有明确的消息类型标识
有统一的分隔符和结束符
包含状态码和描述信息
便于解析和处理

meinvwudi

在这个系统中，监听客户端消息主要通过 ServerSocketClientRead 事件处理，我来详细解释：

首先在 TUserEngine 创建时设置监听：
```
constructor TUserEngine.Create();
begin
  // ... 其他初始化代码 ...
  
  // 创建并设置服务器Socket
  ServerSocket := TServerSocket.Create(nil);
  ServerSocket.Port := g_nGatePort;  // 设置监听端口
  
  // 设置事件处理器
  ServerSocket.OnClientConnect := ServerSocketClientConnect;
  ServerSocket.OnClientDisconnect := ServerSocketClientDisconnect;
  ServerSocket.OnClientRead := ServerSocketClientRead;
  ServerSocket.OnClientError := ServerSocketClientError;
  
  ServerSocket.Active := True; // 开始监听
end;
```
1. 消息接收处理：
```
procedure TUserEngine.ServerSocketClientRead(Socket: TCustomWinSocket);
var
  UserObject: TUserObject;
  sReviceMsg: string;
begin
  if m_boStartService then begin
    UserObject := TUserObject(Socket.nIndex);
    if (UserObject <> nil) and (not UserObject.m_boDisconnect) then begin
      UserObject.Lock;
      try
        // 接收消息
        sReviceMsg := Socket.ReceiveText;
        
        // 消息格式示例: #类型/参数1/参数2!
        // 注册消息: #REGT/username/password!
        // 登录消息: #LOGIN/username/password!
        
        // 检查攻击
        if m_boCheckAttack then begin
          // 长度检查
          if Length(sReviceMsg) > 352 then begin
            // 处理攻击...
          end
          // 其他安全检查...
        end;
        
        // 将消息加入处理队列
        UserObject.m_ReviceMsgList.AddObject(sReviceMsg, TObject(GetTickCount));
        
      finally
        UserObject.UnLock;
      end;
    end;
  end;
end;
```
  1. 消息解析和处理：
```
function TUserEngine.GetUserDataType(Msg: string): Integer;
begin
  Result := -1;
  if (Pos('!', Msg) > 0) and (Length(Msg) >= 2) then begin
    // 解析消息类型
    case Msg[2] of
      'R': Result := CMD_REGISTER;    // 注册
      'L': Result := CMD_LOGIN;       // 登录
      'C': Result := CMD_CHANGEPASS;  // 修改密码
      // ... 其他消息类型
    end;
  end;
end;
```
  2. 消息转发到账号服务器：
```
procedure TUserObject.SendServerMsg(Socket: TCustomWinSocket);
begin
  if m_boSendConnect then begin
    while True do begin
      if m_ReviceMsgList.Count <= 0 then Break;
      
      sReviceMsg := m_ReviceMsgList.Strings[0];
      m_ReviceMsgList.Delete(0);
      
      // 转发给账号服务器
      Socket.SendText('%D' + IntToStr(Integer(Self)) + '/' + sReviceMsg + '$');
    end;
  end;
end;
```
    关键点：
    1. 消息格式规范：
```
#命令类型/参数1/参数2!
例如：
#REGT/用户名/密码!  // 注册
#LOGIN/用户名/密码!  // 登录
```
    2. 安全检查：
    3. 消息长度限制
    4. 消息频率检查
    5. 特殊字符检查
    6. IP黑名单检查
    7. 消息处理流程：
```
客户端发送 -> ServerSocketClientRead接收 
-> 安全检查 -> 加入消息队列 
-> SendServerMsg转发到账号服务器 
-> 等待服务器响应
```
    8. 线程安全：
    9. 使用Lock/UnLock保护关键操作
    10. 使用消息队列缓存处理
    11. 超时控制和异常处理
    这样的设计可以：
    - 有效处理大量并发连接
    - 防止各种攻击
    - 保证消息的可靠传递
    - 方便扩展新的消息类型

meinvwudi

python 模拟的登陆网关

import asyncio
import json
import time
from typing import Dict, List
from dataclasses import dataclass
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# 用户对象类
@dataclass
class UserObject:
    client_socket: asyncio.StreamWriter
    remote_addr: str
    connect_time: float
    last_msg_time: float
    is_connected: bool = True
    msg_count: int = 0
    recv_msgs: List[str] = None
    send_msgs: List[str] = None
    
    def __post_init__(self):
        self.recv_msgs = []
        self.send_msgs = []

class LoginGateway:
    def __init__(self, client_port: int, server_host: str, server_port: int):
        # 配置
        self.client_port = client_port
        self.server_host = server_host 
        self.server_port = server_port
        
        # 状态
        self.is_running = False
        self.server_connected = False
        
        # 用户管理
        self.users: Dict[str, UserObject] = {}  # addr -> UserObject
        self.user_ips: Dict[str, List[UserObject]] = {}  # ip -> [UserObject]
        self.block_ips: Dict[str, int] = {}  # ip -> block_count
        
        # 限制配置
        self.max_msg_len = 352
        self.max_ip_conn = 5
        self.msg_check_interval = 0.1  # 100ms
        
        # 锁
        self._lock = asyncio.Lock()

    async def start(self):
        """启动网关服务"""
        self.is_running = True
        
        # 连接账号服务器
        try:
            self.server_reader, self.server_writer = await asyncio.open_connection(
                self.server_host, self.server_port)
            self.server_connected = True
            logger.info("Connected to account server")
        except Exception as e:
            logger.error(f"Failed to connect account server: {e}")
            return

        # 启动客户端监听服务
        server = await asyncio.start_server(
            self.handle_client,
            '0.0.0.0', 
            self.client_port
        )
        
        logger.info(f"Gateway started on port {self.client_port}")
        
        # 启动消息处理循环
        asyncio.create_task(self.process_messages())
        
        async with server:
            await server.serve_forever()

    async def handle_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
        """处理客户端连接"""
        addr = writer.get_extra_info('peername')
        ip = addr[0]
        
        # 检查IP是否被封禁
        if ip in self.block_ips:
            writer.close()
            return
            
        # 检查IP连接数限制
        async with self._lock:
            if ip in self.user_ips and len(self.user_ips[ip]) >= self.max_ip_conn:
                writer.close()
                return
                
            # 创建用户对象
            user = UserObject(
                client_socket=writer,
                remote_addr=addr,
                connect_time=time.time(),
                last_msg_time=time.time()
            )
            
            # 添加到用户管理
            self.users[addr] = user
            if ip not in self.user_ips:
                self.user_ips[ip] = []
            self.user_ips[ip].append(user)
            
        logger.info(f"Client connected: {addr}")
        
        try:
            while True:
                # 读取消息
                data = await reader.read(1024)
                if not data:
                    break
                    
                msg = data.decode()
                
                # 检查消息
                if not await self.check_message(user, msg):
                    break
                    
                # 加入消息队列
                user.recv_msgs.append(msg)
                user.last_msg_time = time.time()
                user.msg_count += 1
                
        except Exception as e:
            logger.error(f"Client error: {e}")
            
        finally:
            # 清理用户连接
            await self.close_client(addr)

    async def check_message(self, user: UserObject, msg: str) -> bool:
        """检查消息合法性"""
        # 长度检查
        if len(msg) > self.max_msg_len:
            await self.block_ip(user.remote_addr[0])
            return False
            
        # 频率检查
        if time.time() - user.last_msg_time < self.msg_check_interval:
            user.msg_count += 1
            if user.msg_count > 5:
                await self.block_ip(user.remote_addr[0])
                return False
                
        return True

    async def process_messages(self):
        """处理消息队列"""
        while self.is_running:
            try:
                # 处理从客户端收到的消息
                for user in self.users.values():
                    if user.recv_msgs:
                        msg = user.recv_msgs.pop(0)
                        await self.forward_to_server(user, msg)
                        
                # 处理从服务器收到的消息
                if self.server_connected:
                    data = await self.server_reader.read(1024)
                    if data:
                        await self.handle_server_message(data.decode())
                        
            except Exception as e:
                logger.error(f"Process message error: {e}")
                
            await asyncio.sleep(0.001)

    async def forward_to_server(self, user: UserObject, msg: str):
        """转发消息到账号服务器"""
        if not self.server_connected:
            return
            
        # 解析消息类型
        try:
            if msg.startswith("#REGT"):  # 注册消息
                # 格式: #REGT/username/password!
                _, username, password = msg.strip("!").split("/")
                server_msg = f"%D{id(user)}/NewAccount/{username}/{password}$"
                
            elif msg.startswith("#LOGIN"):  # 登录消息 
                # 格式: #LOGIN/username/password!
                _, username, password = msg.strip("!").split("/")
                server_msg = f"%D{id(user)}/Login/{username}/{password}$"
                
            else:
                return
                
            self.server_writer.write(server_msg.encode())
            await self.server_writer.drain()
            
        except Exception as e:
            logger.error(f"Forward message error: {e}")

    async def handle_server_message(self, msg: str):
        """处理服务器返回的消息"""
        try:
            # 解析消息
            if msg.startswith("%R"):  # 注册/登录响应
                # 格式: %R<user_id>/<result>/<message>$
                user_id, result, message = msg[2:].strip("$").split("/")
                
                # 查找用户对象
                for user in self.users.values():
                    if id(user) == int(user_id):
                        # 转换为客户端消息格式
                        if "NewAccount" in message:
                            client_msg = f"#REGT/{result}/{message}!"
                        else:
                            client_msg = f"#LOGIN/{result}/{message}!"
                            
                        # 发送给客户端
                        user.client_socket.write(client_msg.encode())
                        await user.client_socket.drain()
                        break
                        
        except Exception as e:
            logger.error(f"Handle server message error: {e}")

    async def block_ip(self, ip: str):
        """封禁IP"""
        async with self._lock:
            if ip in self.block_ips:
                self.block_ips[ip] += 1
            else:
                self.block_ips[ip] = 1
                
            # 关闭该IP的所有连接
            if ip in self.user_ips:
                for user in self.user_ips[ip]:
                    await self.close_client(user.remote_addr)

    async def close_client(self, addr):
        """关闭客户端连接"""
        async with self._lock:
            if addr in self.users:
                user = self.users[addr]
                user.is_connected = False
                user.client_socket.close()
                await user.client_socket.wait_closed()
                
                # 清理用户管理数据
                ip = addr[0]
                if ip in self.user_ips:
                    self.user_ips[ip].remove(user)
                    if not self.user_ips[ip]:
                        del self.user_ips[ip]
                        
                del self.users[addr]
                
                logger.info(f"Client disconnected: {addr}")

# 使用示例
if __name__ == "__main__":
    gateway = LoginGateway(
        client_port=7000,
        server_host="127.0.0.1",
        server_port=7001
    )
    
    try:
        asyncio.run(gateway.start())
    except KeyboardInterrupt:
        logger.info("Gateway stopped")

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. 统一的消息编码解码机制
这样实现了一个完整的登录网关消息处理系统。