ddns 4.0.2__py2.py3-none-any.whl → 4.1.0b2__py2.py3-none-any.whl

ddns/provider/tencentcloud.py

@@ -0,0 +1,195 @@
+# coding=utf-8
+"""
+Tencent Cloud DNSPod API
+腾讯云 DNSPod API
+
+@author: NewFuture
+"""
+from ._base import BaseProvider, TYPE_JSON
+from ._signature import hmac_sha256_authorization, sha256_hash, hmac_sha256
+from time import time, strftime, gmtime
+
+
+class TencentCloudProvider(BaseProvider):
+    """
+    腾讯云 DNSPod API 提供商
+    Tencent Cloud DNSPod API Provider
+
+    API Version: 2021-03-23
+    Documentation: https://cloud.tencent.com/document/api/1427
+    """
+
+    endpoint = "https://dnspod.tencentcloudapi.com"
+    content_type = TYPE_JSON
+
+    # 腾讯云 DNSPod API 配置
+    service = "dnspod"
+    version_date = "2021-03-23"
+
+    def _request(self, action, **params):
+        # type: (str, **(str | int | bytes | bool | None)) -> dict | None
+        """
+        发送腾讯云 API 请求
+
+        API 文档: https://cloud.tencent.com/document/api/1427/56187
+
+        Args:
+            action (str): API 操作名称
+            params (dict): 请求参数
+
+        Returns:
+            dict: API 响应结果
+        """
+        # 构建请求体
+        params = {k: v for k, v in params.items() if v is not None}
+        body = self._encode_body(params)
+
+        # 构建请求头,小写 腾讯云只签名特定头部
+        headers = {
+            "content-type": self.content_type,
+            "host": self.endpoint.split("://", 1)[1].strip("/"),
+        }
+
+        # 腾讯云特殊的密钥派生过程
+        date = strftime("%Y-%m-%d", gmtime())
+        credential_scope = "{}/{}/tc3_request".format(date, self.service)
+
+        # 派生签名密钥
+        secret_date = hmac_sha256("TC3" + self.token, date).digest()
+        secret_service = hmac_sha256(secret_date, self.service).digest()
+        signing_key = hmac_sha256(secret_service, "tc3_request").digest()
+
+        # 预处理模板字符串
+        auth_format = "TC3-HMAC-SHA256 Credential=%s/%s, SignedHeaders={SignedHeaders}, Signature={Signature}" % (
+            self.id,
+            credential_scope,
+        )
+        timestamp = str(int(time()))
+        sign_template = "\n".join(["TC3-HMAC-SHA256", timestamp, credential_scope, "{HashedCanonicalRequest}"])
+        authorization = hmac_sha256_authorization(
+            secret_key=signing_key,
+            method="POST",
+            path="/",
+            query="",
+            headers=headers,
+            body_hash=sha256_hash(body),
+            signing_string_format=sign_template,
+            authorization_format=auth_format,
+        )
+        # X-TC 更新签名之后方可添加
+        headers.update(
+            {
+                "X-TC-Action": action,
+                "X-TC-Version": self.version_date,
+                "X-TC-Timestamp": timestamp,
+                "authorization": authorization,
+            }
+        )
+
+        response = self._http("POST", "/", body=body, headers=headers)
+        if response and "Response" in response:
+            if "Error" in response["Response"]:
+                error = response["Response"]["Error"]
+                self.logger.error(
+                    "TencentCloud API error: %s - %s",
+                    error.get("Code", "Unknown"),
+                    error.get("Message", "Unknown error"),
+                )
+                return None
+            return response["Response"]
+
+        self.logger.warning("Unexpected response format: %s", response)
+        return None
+
+    def _query_zone_id(self, domain):
+        # type: (str) -> str | None
+        """查询域名的 zone_id (domain id) https://cloud.tencent.com/document/api/1427/56173"""
+        # 使用 DescribeDomain API 查询指定域名的信息
+        response = self._request("DescribeDomain", Domain=domain)
+
+        if not response or "DomainInfo" not in response:
+            self.logger.debug("Domain info not found or query failed for: %s", domain)
+            return None
+
+        domain_id = response.get("DomainInfo", {}).get("DomainId")
+
+        if domain_id is not None:
+            self.logger.debug("Found domain %s with ID: %s", domain, domain_id)
+            return str(domain_id)
+
+        self.logger.debug("Domain ID not found in response for: %s", domain)
+        return None
+
+    def _query_record(self, zone_id, subdomain, main_domain, record_type, line, extra):
+        # type: (str, str, str, str, str | None, dict) -> dict | None
+        """查询 DNS 记录列表 https://cloud.tencent.com/document/api/1427/56166"""
+
+        response = self._request(
+            "DescribeRecordList",
+            DomainId=int(zone_id),
+            Subdomain=subdomain,
+            Domain=main_domain,
+            RecordType=record_type,
+            RecordLine=line,
+            **extra
+        )
+        if not response or "RecordList" not in response:
+            self.logger.debug("No records found or query failed")
+            return None
+
+        records = response["RecordList"]
+        if not records:
+            self.logger.debug("No records found for subdomain: %s", subdomain)
+            return None
+
+        # 查找匹配的记录
+        target_name = subdomain if subdomain and subdomain != "@" else "@"
+        for record in records:
+            if record.get("Name") == target_name and record.get("Type") == record_type.upper():
+                self.logger.debug("Found existing record: %s", record)
+                return record
+
+        self.logger.debug("No matching record found")
+        return None
+
+    def _create_record(self, zone_id, subdomain, main_domain, value, record_type, ttl, line, extra):
+        """创建 DNS 记录 https://cloud.tencent.com/document/api/1427/56180"""
+        extra["Remark"] = extra.get("Remark", self.remark)
+        response = self._request(
+            "CreateRecord",
+            Domain=main_domain,
+            DomainId=int(zone_id),
+            SubDomain=subdomain,
+            RecordType=record_type,
+            Value=value,
+            RecordLine=line or "默认",
+            TTL=int(ttl) if ttl else None,
+            **extra
+        )
+        if response and "RecordId" in response:
+            self.logger.info("Record created successfully with ID: %s", response["RecordId"])
+            return True
+        self.logger.error("Failed to create record:\n%s", response)
+        return False
+
+    def _update_record(self, zone_id, old_record, value, record_type, ttl, line, extra):
+        """更新 DNS 记录: https://cloud.tencent.com/document/api/1427/56157"""
+        extra["Remark"] = extra.get("Remark", self.remark)
+        response = self._request(
+            "ModifyRecord",
+            Domain=old_record.get("Domain", ""),
+            DomainId=old_record.get("DomainId", int(zone_id)),
+            SubDomain=old_record.get("Name"),
+            RecordId=old_record.get("RecordId"),
+            RecordType=record_type,
+            RecordLine=old_record.get("Line", line or "默认"),
+            Value=value,
+            TTL=int(ttl) if ttl else None,
+            **extra
+        )
+        if response and "RecordId" in response:
+            self.logger.info("Record updated successfully")
+            return True
+
+        self.logger.error("Failed to update record")
+        return False

ddns/util/comment.py

@@ -0,0 +1,88 @@
+# -*- coding:utf-8 -*-
+"""
+Comment removal utility for JSON configuration files.
+Supports both # and // style single line comments.
+@author: GitHub Copilot
+"""
+
+
+def remove_comment(content):
+    # type: (str) -> str
+    """
+    移除字符串中的单行注释。
+    支持 # 和 // 两种注释风格。
+
+    Args:
+        content (str): 包含注释的字符串内容
+
+    Returns:
+        str: 移除注释后的字符串
+
+    Examples:
+        >>> remove_comment('{"key": "value"} // comment')
+        '{"key": "value"} '
+        >>> remove_comment('# This is a comment\\n{"key": "value"}')
+        '\\n{"key": "value"}'
+    """
+    if not content:
+        return content
+
+    lines = content.splitlines()
+    cleaned_lines = []
+
+    for line in lines:
+        # 移除行内注释，但要小心不要破坏字符串内的内容
+        cleaned_line = _remove_line_comment(line)
+        cleaned_lines.append(cleaned_line)
+
+    return "\n".join(cleaned_lines)
+
+
+def _remove_line_comment(line):
+    # type: (str) -> str
+    """
+    移除单行中的注释部分。
+
+    Args:
+        line (str): 要处理的行
+
+    Returns:
+        str: 移除注释后的行
+    """
+    # 检查是否是整行注释
+    stripped = line.lstrip()
+    if stripped.startswith("#") or stripped.startswith("//"):
+        return ""
+
+    # 查找行内注释，需要考虑字符串内容
+    in_string = False
+    quote_char = None
+    i = 0
+
+    while i < len(line):
+        char = line[i]
+
+        # 处理字符串内的转义序列
+        if in_string and char == "\\" and i + 1 < len(line):
+            i += 2  # 跳过转义字符
+            continue
+
+        # 处理引号字符
+        if char in ('"', "'"):
+            if not in_string:
+                in_string = True
+                quote_char = char
+            elif char == quote_char:
+                in_string = False
+                quote_char = None
+
+        # 在字符串外检查注释标记
+        elif not in_string:
+            if char == "#":
+                return line[:i].rstrip()
+            elif char == "/" and i + 1 < len(line) and line[i + 1] == "/":
+                return line[:i].rstrip()
+
+        i += 1
+
+    return line

ddns/util/http.py

@@ -0,0 +1,228 @@
+# 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 urllib.request import Request, HTTPSHandler, ProxyHandler, build_opener, OpenerDirector  # noqa: F401
+    from urllib.parse import quote, urlencode
+    from urllib.error import HTTPError, URLError
+except ImportError:  # python 2
+    from urllib2 import Request, HTTPSHandler, ProxyHandler, build_opener, HTTPError, URLError  # type: ignore[no-redef]
+    from urllib import urlencode, quote  # type: ignore[no-redef]
+
+__all__ = [
+    "send_http_request",
+    "HttpResponse",
+    "quote",
+    "urlencode",
+    "URLError",
+]
+
+logger = getLogger().getChild(__name__)
+
+
+class HttpResponse(object):
+    """HTTP响应封装类"""
+
+    def __init__(self, status, reason, headers, body):
+        # type: (int, str, object, str) -> None
+        """
+        初始化HTTP响应对象
+
+        Args:
+            status (int): HTTP状态码
+            reason (str): 状态原因短语
+            headers (object): 响应头对象，直接使用 response.info()
+            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): 头部名称
+            default (str | None): 默认值
+
+        Returns:
+            str | None: 头部值，如果不存在则返回默认值
+        """
+        return self.headers.get(name, default)  # type: ignore[union-attr]
+
+
+# 移除了自定义重定向处理器，使用urllib2/urllib.request的内置重定向处理
+
+
+def _create_ssl_context(verify_ssl):
+    # type: (bool | str) -> ssl.SSLContext | None
+    """创建SSL上下文"""
+    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证书
+        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)
+            return None
+    else:
+        # 默认验证，尝试加载系统证书
+        _load_system_ca_certs(ssl_context)
+
+    return ssl_context
+
+
+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.info("Failed to load CA certificates from %s: %s", ca_path, e)
+
+
+def _create_opener(proxy, verify_ssl):
+    # type: (str | None, bool | str) -> OpenerDirector
+    """创建URL打开器，支持代理和SSL配置"""
+    handlers = []
+
+    if proxy:
+        handlers.append(ProxyHandler({"http": proxy, "https": proxy}))
+
+    ssl_context = _create_ssl_context(verify_ssl)
+    if ssl_context:
+        handlers.append(HTTPSHandler(context=ssl_context))
+
+    return build_opener(*handlers)
+
+
+def send_http_request(method, url, body=None, headers=None, proxy=None, verify_ssl=True):
+    # type: (str, str, str | bytes | None, dict[str, str] | None, str | None, bool | str) -> HttpResponse
+    """
+    发送HTTP/HTTPS请求，支持重定向跟随和灵活的SSL验证
+
+    Args:
+        method (str): HTTP方法，如GET、POST等
+        url (str): 请求的URL
+        body (str | bytes | None): 请求体
+        headers (dict[str, str] | None): 请求头
+        proxy (str | None): 代理地址
+        verify_ssl (bool | str): SSL验证配置
+
+    Returns:
+        HttpResponse: 响应对象
+
+    Raises:
+        URLError: 如果请求失败
+        ssl.SSLError: 如果SSL验证失败
+    """
+    # 准备请求
+    if isinstance(body, str):
+        body = body.encode("utf-8")
+
+    req = Request(url, data=body)
+    req.get_method = lambda: method  # type: ignore[attr-defined]
+
+    if headers:
+        for key, value in headers.items():
+            req.add_header(key, value)
+
+    # 创建opener并发送请求
+    opener = _create_opener(proxy, verify_ssl)
+
+    try:
+        response = opener.open(req)
+        response_headers = response.info()
+        raw_body = response.read()
+        decoded_body = _decode_response_body(raw_body, response_headers.get("Content-Type"))
+        return HttpResponse(response.getcode(), getattr(response, "msg", ""), response_headers, decoded_body)
+    except HTTPError as e:
+        # 记录HTTP错误并读取响应体用于调试
+        response_headers = getattr(e, "headers", {})
+        raw_body = e.read()
+        decoded_body = _decode_response_body(raw_body, response_headers.get("Content-Type"))
+        logger.error("HTTP error %s: %s for %s", e.code, getattr(e, "reason", str(e)), url)
+        return HttpResponse(e.code, getattr(e, "reason", str(e)), response_headers, decoded_body)
+    except ssl.SSLError:
+        if verify_ssl == "auto":
+            logger.warning("SSL verification failed, switching to unverified connection %s", url)
+            return send_http_request(method, url, body, headers, proxy, False)
+        else:
+            raise
+
+
+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")