ddns 4.0.1__py2.py3-none-any.whl → 4.1.0b1__py2.py3-none-any.whl

ddns/util/cache.py

@@ -4,30 +4,25 @@ cache module
 文件缓存
 """
 
-
 from os import path, stat
 from pickle import dump, load
 from time import time
+from logging import getLogger, Logger  # noqa: F401
 
-from logging import info, debug, warning
-
-try:  # python 3
-    from collections.abc import MutableMapping
-except ImportError:  # python 2
-    from collections import MutableMapping
 
-
-class Cache(MutableMapping):
+class Cache(dict):
     """
     using file to Cache data as dictionary
     """
 
-    def __init__(self, path, sync=False):
-        self.__data = {}
+    def __init__(self, path, logger=None, sync=False):
+        # type: (str, Logger | None, bool) -> None
+        super(Cache, self).__init__()
         self.__filename = path
         self.__sync = sync
         self.__time = time()
         self.__changed = False
+        self.__logger = (logger or getLogger()).getChild("Cache")
         self.load()
 
     @property
@@ -35,7 +30,7 @@ class Cache(MutableMapping):
         """
         缓存修改时间
         """
-        return self.__time
+        return self.__time or 0
 
     def load(self, file=None):
         """
@@ -44,44 +39,35 @@ class Cache(MutableMapping):
         if not file:
             file = self.__filename
 
-        debug('load cache data from %s', file)
-        if path.isfile(file):
-            with open(self.__filename, 'rb') as data:
+        self.__logger.debug("load cache data from %s", file)
+        if file and path.isfile(file):
+            with open(file, "rb") as data:
                 try:
-                    self.__data = load(data)
+                    loaded_data = load(data)
+                    self.clear()
+                    self.update(loaded_data)
                     self.__time = stat(file).st_mtime
                     return self
                 except ValueError:
                     pass
                 except Exception as e:
-                    warning(e)
+                    self.__logger.warning(e)
         else:
-            info('cache file not exist')
+            self.__logger.info("cache file not exist")
 
-        self.__data = {}
+        self.clear()
         self.__time = time()
         self.__changed = True
         return self
 
-    def data(self, key=None, default=None):
-        """
-        获取当前字典或者制定得键值
-        """
-        if self.__sync:
-            self.load()
-
-        if key is None:
-            return self.__data
-        else:
-            return self.__data.get(key, default)
-
     def sync(self):
-        """Sync the write buffer with the cache files and clear the buffer.
-        """
-        if self.__changed:
-            with open(self.__filename, 'wb') as data:
-                dump(self.__data, data)
-                debug('save cache data to %s', self.__filename)
+        """Sync the write buffer with the cache files and clear the buffer."""
+        if self.__changed and self.__filename:
+            with open(self.__filename, "wb") as data:
+                # 只保存非私有字段（不以__开头的字段）
+                filtered_data = {k: v for k, v in super(Cache, self).items() if not k.startswith("__")}
+                dump(filtered_data, data)
+                self.__logger.debug("save cache data to %s", self.__filename)
             self.__time = time()
             self.__changed = False
         return self
@@ -91,10 +77,10 @@ class Cache(MutableMapping):
         If a closed :class:`FileCache` object's methods are called, a
         :exc:`ValueError` will be raised.
         """
-        self.sync()
-        del self.__data
-        del self.__filename
-        del self.__time
+        if self.__filename:
+            self.sync()
+        self.__filename = None
+        self.__time = None
         self.__sync = False
 
     def __update(self):
@@ -105,35 +91,62 @@ class Cache(MutableMapping):
             self.__time = time()
 
     def clear(self):
-        if self.data() is not None:
-            self.__data = {}
+        # 只清除非私有字段（不以__开头的字段）
+        keys_to_remove = [key for key in super(Cache, self).keys() if not key.startswith("__")]
+        if keys_to_remove:
+            for key in keys_to_remove:
+                super(Cache, self).__delitem__(key)
             self.__update()
 
+    def get(self, key, default=None):
+        """
+        获取指定键的值，如果键不存在则返回默认值
+        :param key: 键
+        :param default: 默认值
+        :return: 键对应的值或默认值
+        """
+        if key is None and default is None:
+            return {k: v for k, v in super(Cache, self).items() if not k.startswith("__")}
+        return super(Cache, self).get(key, default)
+
     def __setitem__(self, key, value):
-        if self.data(key) != value:
-            self.__data[key] = value
-            self.__update()
+        if self.get(key) != value:
+            super(Cache, self).__setitem__(key, value)
+            # 私有字段（以__开头）不触发同步
+            if not key.startswith("__"):
+                self.__update()
 
     def __delitem__(self, key):
-        if key in self.data():
-            del self.__data[key]
+        # 检查键是否存在，如果不存在则直接返回，不抛错
+        if not super(Cache, self).__contains__(key):
+            return
+        super(Cache, self).__delitem__(key)
+        # 私有字段（以__开头）不触发同步
+        if not key.startswith("__"):
             self.__update()
 
     def __getitem__(self, key):
-        return self.data(key)
+        return super(Cache, self).__getitem__(key)
 
     def __iter__(self):
-        for key in self.data():
-            yield key
+        # 只迭代非私有字段（不以__开头的字段）
+        for key in super(Cache, self).__iter__():
+            if not key.startswith("__"):
+                yield key
+
+    def __items__(self):
+        # 只返回非私有字段（不以__开头的字段）
+        return ((key, value) for key, value in super(Cache, self).items() if not key.startswith("__"))
 
     def __len__(self):
-        return len(self.data())
+        # 不计算以__开头的私有字段
+        return len([key for key in super(Cache, self).keys() if not key.startswith("__")])
 
     def __contains__(self, key):
-        return key in self.data()
+        return super(Cache, self).__contains__(key)
 
     def __str__(self):
-        return self.data().__str__()
+        return super(Cache, self).__str__()
 
     def __del__(self):
         self.close()

ddns/util/config.py

@@ -54,7 +54,7 @@ def parse_array_string(value, enable_simple_split):
     仅当 trim 之后以 '[' 开头以 ']' 结尾时，才尝试使用 ast.literal_eval 解析
     默认返回原始字符串
     """
-    if not isinstance(value, str):
+    if not hasattr(value, "strip"):  # 非字符串
         return value
 
     trimmed = value.strip()
@@ -71,10 +71,10 @@ def parse_array_string(value, enable_simple_split):
     elif enable_simple_split:
         # 尝试使用逗号或分号分隔符解析
         sep = None
-        if ',' in trimmed:
-            sep = ','
-        elif ';' in trimmed:
-            sep = ';'
+        if "," in trimmed:
+            sep = ","
+        elif ";" in trimmed:
+            sep = ";"
         if sep:
             return [item.strip() for item in trimmed.split(sep) if item.strip()]
     return value
@@ -84,9 +84,8 @@ def get_system_info_str():
     system = platform.system()
     release = platform.release()
     machine = platform.machine()
-    arch = platform.architecture()[0]  # '64bit' or '32bit'
-
-    return "{}-{} {} ({})".format(system, release, machine, arch)
+    arch = platform.architecture()
+    return "{}-{} {} {}".format(system, release, machine, arch)
 
 
 def get_python_info_str():
@@ -100,21 +99,13 @@ def init_config(description, doc, version, date):
     配置
     """
     global __cli_args
-    parser = ArgumentParser(
-        description=description, epilog=doc, formatter_class=RawTextHelpFormatter
-    )
+    parser = ArgumentParser(description=description, epilog=doc, formatter_class=RawTextHelpFormatter)
     sysinfo = get_system_info_str()
     pyinfo = get_python_info_str()
     version_str = "v{} ({})\n{}\n{}".format(version, date, pyinfo, sysinfo)
     parser.add_argument("-v", "--version", action="version", version=version_str)
-    parser.add_argument(
-        "-c", "--config", metavar="FILE", help="load config file [配置文件路径]"
-    )
-    parser.add_argument(
-        "--debug",
-        action="store_true",
-        help="debug mode [调试模式等效 --log.level=DEBUG]",
-    )
+    parser.add_argument("-c", "--config", metavar="FILE", help="load config file [配置文件路径]")
+    parser.add_argument("--debug", action="store_true", help="debug mode [开启调试模式]")
 
     # 参数定义
     parser.add_argument(
@@ -129,6 +120,7 @@ def init_config(description, doc, version, date):
             "he",
             "huaweidns",
             "callback",
+            "debug",
         ],
     )
     parser.add_argument("--id", help="API ID or email [对应账号ID或邮箱]")
@@ -162,6 +154,7 @@ def init_config(description, doc, version, date):
         help="IPv6 domains [IPv6域名列表, 可配置多个域名]",
     )
     parser.add_argument("--ttl", type=int, help="DNS TTL(s) [设置域名解析过期时间]")
+    parser.add_argument("--line", help="DNS line/route [DNS线路设置，如电信、联通、移动等]")
     parser.add_argument(
         "--proxy",
         nargs="*",
@@ -183,23 +176,25 @@ def init_config(description, doc, version, date):
         help="disable cache [关闭缓存等效 --cache=false]",
     )
     parser.add_argument(
-        "--log.file", metavar="FILE", help="log file [日志文件，默认标准输出]"
+        "--ssl",
+        help="SSL certificate verification [SSL证书验证方式]: "
+        "true(强制验证), false(禁用验证), auto(自动降级), /path/to/cert.pem(自定义证书)",
     )
+    parser.add_argument("--log.file", metavar="FILE", help="log file [日志文件，默认标准输出]")
     parser.add_argument("--log.level", type=log_level, metavar="|".join(log_levels))
-    parser.add_argument(
-        "--log.format", metavar="FORMAT", help="log format [设置日志打印格式]"
-    )
-    parser.add_argument(
-        "--log.datefmt", metavar="FORMAT", help="date format [日志时间打印格式]"
-    )
+    parser.add_argument("--log.format", metavar="FORMAT", help="log format [设置日志打印格式]")
+    parser.add_argument("--log.datefmt", metavar="FORMAT", help="date format [日志时间打印格式]")
 
     __cli_args = parser.parse_args()
-    if __cli_args.debug:
-        # 如果启用调试模式，则设置日志级别为 DEBUG
+    is_debug = getattr(__cli_args, "debug", False)
+    if is_debug:
+        # 如果启用调试模式，则强制设置日志级别为 DEBUG
         setattr(__cli_args, "log.level", log_level("DEBUG"))
+        if not hasattr(__cli_args, "cache"):
+            setattr(__cli_args, "cache", False)  # 禁用缓存
 
-    is_configfile_required = not get_config("token") and not get_config("id")
-    config_file = get_config("config")
+    config_required = not get_config("token") and not get_config("id")
+    config_file = get_config("config")  # type: str | None # type: ignore
     if not config_file:
         # 未指定配置文件且需要读取文件时，依次查找
         cfgs = [
@@ -212,7 +207,7 @@ def init_config(description, doc, version, date):
     if path.isfile(config_file):
         __load_config(config_file)
         __cli_args.config = config_file
-    elif is_configfile_required:
+    elif config_required:
         error("Config file is required, but not found: %s", config_file)
         # 如果需要配置文件但没有指定，则自动生成
         if generate_config(config_file):
@@ -296,13 +291,15 @@ def generate_config(config_path):
         "$schema": "https://ddns.newfuture.cc/schema/v4.0.json",
         "id": "YOUR ID or EMAIL for DNS Provider",
         "token": "YOUR TOKEN or KEY for DNS Provider",
-        "dns": "dnspod",
+        "dns": "debug",  # DNS Provider, default is print
         "ipv4": ["newfuture.cc", "ddns.newfuture.cc"],
         "ipv6": ["newfuture.cc", "ipv6.ddns.newfuture.cc"],
         "index4": "default",
         "index6": "default",
         "ttl": None,
+        "line": None,
         "proxy": None,
+        "ssl": "auto",
         "log": {"level": "INFO"},
     }
     try:

ddns/util/http.py

@@ -0,0 +1,277 @@
+# coding=utf-8
+"""
+HTTP请求工具模块
+
+HTTP utilities module for DDNS project.
+Provides common HTTP functionality including redirect following support.
+
+@author: NewFuture
+"""
+
+from logging import getLogger
+import ssl
+import os
+
+try:  # python 3
+    from http.client import HTTPSConnection, HTTPConnection, HTTPException
+    from urllib.parse import urlparse
+except ImportError:  # python 2
+    from httplib import HTTPSConnection, HTTPConnection, HTTPException  # type: ignore[no-redef]
+    from urlparse import urlparse  # type: ignore[no-redef]
+
+__all__ = ["send_http_request", "HttpResponse"]
+
+logger = getLogger().getChild(__name__)
+
+
+class HttpResponse(object):
+    """HTTP响应封装类"""
+
+    def __init__(self, status, reason, headers, body):
+        # type: (int, str, list[tuple[str, str]], str) -> None
+        """
+        初始化HTTP响应对象
+
+        Args:
+            status (int): HTTP状态码
+            reason (str): 状态原因短语
+            headers (list[tuple[str, str]]): 响应头列表，保持原始格式和顺序
+            body (str): 响应体内容
+        """
+        self.status = status
+        self.reason = reason
+        self.headers = headers
+        self.body = body
+
+    def get_header(self, name, default=None):
+        # type: (str, str | None) -> str | None
+        """
+        获取指定名称的头部值（不区分大小写）
+
+        Args:
+            name (str): 头部名称
+
+        Returns:
+            str | None: 头部值，如果不存在则返回None
+        """
+        name_lower = name.lower()
+        for header_name, header_value in self.headers:
+            if header_name.lower() == name_lower:
+                return header_value
+        return default
+
+
+def _create_connection(hostname, port, is_https, proxy, verify_ssl):
+    # type: (str, int | None, bool, str | None, bool | str) -> HTTPConnection | HTTPSConnection
+    """创建HTTP/HTTPS连接"""
+    target = proxy or hostname
+
+    if not is_https:
+        conn = HTTPConnection(target, port)
+    else:
+        ssl_context = ssl.create_default_context()
+
+        if verify_ssl is False:
+            # 禁用SSL验证
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+        elif hasattr(verify_ssl, "lower") and verify_ssl.lower() not in ("auto", "true"):  # type: ignore[union-attr]
+            # 使用自定义CA证书 lower 判断 str/unicode 兼容 python2
+            try:
+                ssl_context.load_verify_locations(verify_ssl)  # type: ignore[arg-type]
+            except Exception as e:
+                logger.error("Failed to load CA certificate from %s: %s", verify_ssl, e)
+        else:
+            # 默认验证，尝试加载系统证书
+            _load_system_ca_certs(ssl_context)
+        conn = HTTPSConnection(target, port, context=ssl_context)
+
+    # 设置代理隧道
+    if proxy:
+        conn.set_tunnel(hostname, port)  # type: ignore[attr-defined]
+
+    return conn
+
+
+def _load_system_ca_certs(ssl_context):
+    # type: (ssl.SSLContext) -> None
+    """加载系统CA证书"""
+    # 常见CA证书路径
+    ca_paths = [
+        # Linux/Unix常用路径
+        "/etc/ssl/certs/ca-certificates.crt",  # Debian/Ubuntu
+        "/etc/pki/tls/certs/ca-bundle.crt",  # RedHat/CentOS
+        "/etc/ssl/ca-bundle.pem",  # OpenSUSE
+        "/etc/ssl/cert.pem",  # OpenBSD
+        "/usr/local/share/certs/ca-root-nss.crt",  # FreeBSD
+        "/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem",  # Fedora/RHEL
+        # macOS路径
+        "/usr/local/etc/openssl/cert.pem",  # macOS with Homebrew
+        "/opt/local/etc/openssl/cert.pem",  # macOS with MacPorts
+    ]
+
+    # Windows额外路径
+    if os.name == "nt":
+        ca_paths.append("C:\\Program Files\\Git\\mingw64\\ssl\\cert.pem")
+        ca_paths.append("C:\\Program Files\\OpenSSL\\ssl\\cert.pem")
+
+    loaded_count = 0
+    for ca_path in ca_paths:
+        if os.path.isfile(ca_path):
+            try:
+                ssl_context.load_verify_locations(ca_path)
+                loaded_count += 1
+                logger.debug("Loaded CA certificates from: %s", ca_path)
+            except Exception as e:
+                logger.debug("Failed to load CA certificates from %s: %s", ca_path, e)
+
+    if loaded_count > 0:
+        logger.debug("Successfully loaded CA certificates from %d locations", loaded_count)
+
+
+def _close_connection(conn):
+    # type: (HTTPConnection | HTTPSConnection) -> None
+    """关闭HTTP/HTTPS连接"""
+    try:
+        conn.close()
+    except Exception as e:
+        logger.warning("Failed to close connection: %s", e)
+
+
+def send_http_request(method, url, body=None, headers=None, proxy=None, max_redirects=5, verify_ssl=True):
+    # type: (str, str, str | bytes | None, dict[str, str] | None, str | None, int, bool | str) -> HttpResponse
+    """
+    发送HTTP/HTTPS请求，支持重定向跟随和灵活的SSL验证
+    Send HTTP/HTTPS request with support for redirect following and flexible SSL verification.
+    Args:
+        method (str): HTTP方法，如GET、POST等
+        url (str): 请求的URL
+        body (str | bytes | None): 请求体
+        headers (dict[str, str] | None): 请求头
+        proxy (str | None): 代理地址
+        max_redirects (int): 最大重定向次数
+        verify_ssl (bool | str): 是否验证SSL证书
+    Returns:
+        HttpResponse: 响应对象，包含状态码、头部和解码后的内容
+    Raises:
+        HTTPException: 如果请求失败或重定向次数超过限制
+        ssl.SSLError: 如果SSL验证失败
+    """
+    if max_redirects <= 0:
+        raise HTTPException("Too many redirects")
+
+    # 解析URL
+    url_obj = urlparse(url)
+    is_https = url_obj.scheme == "https"
+    hostname = url_obj.hostname or url_obj.netloc.split(":")[0]
+    request_path = "{}?{}".format(url_obj.path, url_obj.query) if url_obj.query else url_obj.path
+    headers = headers or {}
+
+    # 创建连接
+    actual_verify_ssl = verify_ssl
+    conn = _create_connection(hostname, url_obj.port, is_https, proxy, verify_ssl)
+
+    # 执行请求，处理SSL错误
+    try:
+        conn.request(method, request_path, body, headers)
+        response = conn.getresponse()
+    except ssl.SSLError:
+        _close_connection(conn)
+        if verify_ssl == "auto" and is_https:
+            logger.warning("SSL verification failed, switching to unverified connection %s", url)
+            # 重新连接，忽略SSL验证
+            conn = _create_connection(hostname, url_obj.port, is_https, proxy, False)
+            conn.request(method, request_path, body, headers)
+            response = conn.getresponse()
+            actual_verify_ssl = False
+        else:
+            raise
+
+    # 检查重定向
+    status = response.status
+    if 300 <= status < 400:
+        location = response.getheader("Location")
+        _close_connection(conn)
+        if not location:
+            # 无Location头的重定向
+            logger.warning("Redirect status %d but no Location header", status)
+            location = ""
+
+        # 构建重定向URL
+        redirect_url = _build_redirect_url(location, "{}://{}".format(url_obj.scheme, url_obj.netloc), url_obj.path)
+
+        # 如果重定向URL没有查询字符串，但原始URL有，则附加
+        if url_obj.query and "?" not in redirect_url:
+            redirect_url += "?" + url_obj.query
+
+        # 确定重定向方法：303或302+POST转为GET，其他保持原方法
+        if status == 303 or (status == 302 and method == "POST"):
+            method, body = "GET", None
+            # 如果从POST转为GET，移除相关的头部
+            if headers:
+                headers = {k: v for k, v in headers.items() if k.lower() not in ("content-length", "content-type")}
+
+        logger.info("Redirecting [%d] to: %s", status, redirect_url)
+        # 递归处理重定向
+        return send_http_request(method, redirect_url, body, headers, proxy, max_redirects - 1, actual_verify_ssl)
+
+    # 处理最终响应
+    content_type = response.getheader("Content-Type")
+    response_headers = response.getheaders()
+    raw_body = response.read()
+    _close_connection(conn)
+
+    # 解码响应体并创建响应对象
+    decoded_body = _decode_response_body(raw_body, content_type)
+    return HttpResponse(status, response.reason, response_headers, decoded_body)
+
+
+def _build_redirect_url(location, base, path):
+    # type: (str, str, str) -> str
+    """构建重定向URL，使用简单的字符串操作"""
+    if location.startswith("http"):
+        return location
+
+    if location.startswith("/"):
+        # 绝对路径：使用base的scheme和netloc
+        base_url = urlparse(base)
+        return "{}://{}{}".format(base_url.scheme, base_url.netloc, location)
+    else:
+        base_path = path.rsplit("/", 1)[0] if "/" in path else ""
+        if not base_path.endswith("/"):
+            base_path += "/"
+        return base + base_path + location
+
+
+def _decode_response_body(raw_body, content_type):
+    # type: (bytes, str | None) -> str
+    """解码HTTP响应体，优先使用UTF-8"""
+    if not raw_body:
+        return ""
+
+    # 从Content-Type提取charset
+    charsets = ["utf-8", "gbk", "ascii", "latin-1"]
+    if content_type and "charset=" in content_type.lower():
+        start = content_type.lower().find("charset=") + 8
+        end = content_type.find(";", start)
+        if end == -1:
+            end = len(content_type)
+        charset = content_type[start:end].strip("'\" ").lower()
+        charsets.insert(0, charset)
+        # 处理常见别名
+        if charset == "gb2312":
+            charsets.remove("gbk")
+            charsets.insert(0, "gbk")
+        elif charset == "iso-8859-1":
+            charsets.remove("latin-1")
+            charsets.insert(0, "latin-1")
+
+    # 按优先级尝试解码
+    for encoding in charsets:
+        try:
+            return raw_body.decode(encoding)
+        except (UnicodeDecodeError, LookupError):
+            continue
+
+    # 最终后备：UTF-8替换错误字符
+    return raw_body.decode("utf-8", errors="replace")