[Support Request] whois 通过代理后请求变慢，如何解决？

[quyunet]

Checks

• I have searched the existing issues
• I have read the documentation
• Is it your first time sumbitting an issue

Support Request

whois是一个通过tcp协议请求43端口的工具，当启动dae后，whois 通过代理后请求变慢，其实请求已经输出了所有数据，但仍然会阻塞10秒后再结束，请求命令：
whois 888.md

等待时间是10秒后结束。

以下是dae的动态日志：

以下是tcpdump抓包dae0网卡的详情：

我发现每次都是卡顿10秒，是固定的，包括查询其他域名，都是阻塞10秒后结束，是有规律的，就不知道是哪里设置出了问题。

dae配置内容如下：

global {
    lan_interface: eth0
    wan_interface: auto
    log_level: info
    auto_config_kernel_parameter: true
    dial_mode: domain
    allow_insecure: false
    sniffing_timeout: 100ms
    so_mark_from_dae: 1234

    # tls配置
    tls_implementation: utls
    utls_imitate: chrome_auto
}

subscription {
}

node {
    # 节点URI
    HK: 'hysteria2://xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
}

group {
    my_proxy {
        policy: fixed(0)
    }
}

dns {
  ipversion_prefer: 4
  
  upstream {
    googledns: 'tcp+udp://dns.google:53'
    alidns: 'udp://dns.alidns.com:53'
    tencentdns: 'udp://183.60.82.98:53'
  }
  routing {
    request {
        qname(suffix: .tencentyun.com) -> tencentdns    # 指定域名，优先
        qname(geosite:category-ads-all) -> reject
        qname(geosite:cn) -> alidns
        fallback: googledns
    }
    response {
        upstream(googledns) -> accept
        ip(geoip:private) && !qname(geosite:cn) -> googledns
        fallback: accept
    }
  }
}

routing {
    pname(NetworkManager) -> direct
  dip(172.16.16.0/20, 172.16.0.0/12, 192.168.0.0/16, 10.0.0.0/8, 'fe80::/64') -> direct
    dip(geoip:private) -> direct
    dip(geoip:cn) -> direct
    domain(geosite:cn) -> direct
  !dip(geoip:cn) && pname(dig) -> must_my_proxy
  # pname(systemd-resolved, dnsmasq, dig) -> must_direct      ### 进程名称规则（绑定WAN时仅支持本机进程）
  domain(suffix: nic.md) -> my_proxy
  dport(43) -> must_direct
    domain(geosite:category-ads) -> block
    domain(suffix: .tencentyun.com, suffix: direct.com) -> direct
    fallback: my_proxy
}

Current Behavior

whois 888.md
whois 888.com
或者：
echo "888.md" | telnet whois.nic.md 43
echo "888.md" | nc whois.nic.md 43

Expected Behavior

结果输出正常，但需要多耗10后才结束，输出结果后不应该等那么长的时间才结束的。

Steps to Reproduce

apt install whois
/usr/bin/dae run --disable-timestamp -c /etc/dae/config.dae
whois 888.md

Environment

• **OS: Debian 12.0 64 bit
• **Kernel : Linux VM-debian 6.1.0-21-amd64
• **Dae version：0.8.0 rc1

Anything else?

No response

[dae-prow[bot]]

Thanks for opening this issue!

[Jecvay]

不如直接跳过他 !dport(80) && !dport(443) && !dport(853) -> direct

[quyunet]

不如直接跳过他 !dport(80) && !dport(443) && !dport(853) -> direct

跳过他固然是一个方案，但不是最好的解决方案，有些主机必须使用proxy才能访问或者访问更快速，所以不是最终的解决办法。

[quyunet]

The problem was solved after re-defining a whois query script using python. The conventional query method is often unable to adapt to the proxy network environment.

import socket
import select
import time

def query_whois_socket(domain, server="whois.nic.md", port=43, timeout=5):
    """
    Query WHOIS information using socket, simulating ncat request with optimized response time.
    
    Args:
        domain (str): Domain to query.
        server (str): WHOIS server address.
        port (int): WHOIS server port.
        timeout (int): Socket timeout in seconds.
    
    Returns:
        str: WHOIS query result.
    """
    try:
        # Create socket
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.setblocking(False)
        
        # Connect to server
        try:
            s.connect((server, port))
        except BlockingIOError:
            pass
        
        # Wait for connection
        connection_start = time.time()
        _, writable, exceptional = select.select([], [s], [s], timeout)
        
        if not writable:
            raise socket.timeout("Connection timeout")
        if exceptional:
            raise Exception("Connection error")
        
        # Send request
        s.sendall(f"{domain}\r\n".encode())
        
        # Receive response
        response = b""
        last_data_time = time.time()
        quiet_period = 0.2
        
        while True:
            readable, _, _ = select.select([s], [], [], min(0.1, timeout))
            
            if readable:
                try:
                    chunk = s.recv(4096)
                    if not chunk:
                        break
                    response += chunk
                    last_data_time = time.time()
                except (socket.timeout, BlockingIOError):
                    pass
            
            current_time = time.time()
            if response and current_time - last_data_time > quiet_period:
                break
            if current_time - connection_start > timeout:
                break
        
        s.close()
        return response.decode('utf-8', errors='ignore')
    except Exception as e:
        return f"Error occurred: {e}"

def main():
    import sys
    domain_to_lookup = sys.argv[1] if len(sys.argv) > 1 else "888.md"
    
    start_time = time.time()
    whois_info = query_whois_socket(domain_to_lookup, "whois.nic.md", 43, 5)
    print(whois_info)
    print(f"Query time: {time.time() - start_time:.2f} seconds")

if __name__ == "__main__":
    main()