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

ddns/provider/namesilo.py

@@ -0,0 +1,159 @@
+# coding=utf-8
+"""
+NameSilo API Provider
+DNS provider implementation for NameSilo domain registrar
+@doc: https://www.namesilo.com/api-reference
+@author: NewFuture & Copilot
+"""
+
+from ._base import BaseProvider, TYPE_JSON
+
+
+class NamesiloProvider(BaseProvider):
+    """
+    NameSilo DNS API Provider
+
+    Supports DNS record management through NameSilo's API including:
+    - Domain information retrieval
+    - DNS record listing
+    - DNS record creation
+    - DNS record updating
+    """
+
+    endpoint = "https://www.namesilo.com"
+    content_type = TYPE_JSON
+
+    def _validate(self):
+        """Validate authentication credentials"""
+        # NameSilo only requires API key (token), not ID
+        if not self.token:
+            raise ValueError("API key (token) must be configured for NameSilo")
+        if not self.endpoint:
+            raise ValueError("API endpoint must be defined in {}".format(self.__class__.__name__))
+
+        # Warn if ID is configured since NameSilo doesn't need it
+        if self.id:
+            self.logger.warning("NameSilo does not require 'id' configuration - only API key (token) is needed")
+
+        # Show pending verification warning
+        self.logger.warning("NameSilo provider implementation is pending verification - please test thoroughly")
+
+    def _request(self, operation, **params):
+        # type: (str, **(str | int | bytes | bool | None)) -> dict|None
+        """
+        Send request to NameSilo API
+
+        Args:
+            operation (str): API operation name
+            params: API parameters
+
+        Returns:
+            dict: API response data
+        """
+        # Filter out None parameters
+        params = {k: v for k, v in params.items() if v is not None}
+
+        # Add required authentication and format parameters
+        params.update({"version": "1", "type": "json", "key": self.token})
+
+        # Make API request
+        response = self._http("GET", "/api/" + operation, queries=params)
+
+        # Parse response
+        if response and isinstance(response, dict):
+            reply = response.get("reply", {})
+
+            # Check for successful response
+            if reply.get("code") == "300":  # NameSilo success code
+                return reply
+            else:
+                # Log error details
+                error_msg = reply.get("detail", "Unknown error")
+                self.logger.warning("NameSilo API error [%s]: %s", reply.get("code", "unknown"), error_msg)
+
+        return None
+
+    def _query_zone_id(self, domain):
+        # type: (str) -> str | None
+        """
+        Query domain information to get domain as zone identifier
+        @doc: https://www.namesilo.com/api-reference#domains/get-domain-info
+        """
+        response = self._request("getDomainInfo", domain=domain)
+
+        if response:
+            # Domain exists, return the domain name as zone_id
+            domain_info = response.get("domain", {})
+            if domain_info:
+                self.logger.debug("Domain found: %s", domain)
+                return domain
+
+        self.logger.warning("Domain not found or not accessible: %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
+        """
+        Query existing DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/list-dns-records
+        """
+        response = self._request("dnsListRecords", domain=main_domain)
+
+        if response:
+            records = response.get("resource_record", [])
+
+            # Find matching record
+            for record in records:
+                if record.get("host") == subdomain and record.get("type") == record_type:
+                    self.logger.debug("Found existing record: %s", record)
+                    return record
+
+        self.logger.debug("No matching record found for %s.%s (%s)", subdomain, main_domain, record_type)
+        return None
+
+    def _create_record(self, zone_id, subdomain, main_domain, value, record_type, ttl, line, extra):
+        # type: (str, str, str, str, str, int | str | None, str | None, dict) -> bool
+        """
+        Create new DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/add-dns-record
+        """
+        response = self._request(
+            "dnsAddRecord", domain=main_domain, rrtype=record_type, rrhost=subdomain, rrvalue=value, rrttl=ttl
+        )
+
+        if response:
+            record_id = response.get("record_id")
+            self.logger.info("DNS record created successfully: %s", record_id)
+            return True
+        else:
+            self.logger.error("Failed to create DNS record")
+            return False
+
+    def _update_record(self, zone_id, old_record, value, record_type, ttl, line, extra):
+        # type: (str, dict, str, str, int | str | None, str | None, dict) -> bool
+        """
+        Update existing DNS record
+        @doc: https://www.namesilo.com/api-reference#dns/update-dns-record
+        """
+        record_id = old_record.get("record_id")
+        if not record_id:
+            self.logger.error("No record_id found in old_record: %s", old_record)
+            return False
+
+        # In NameSilo, zone_id is the main domain name
+        response = self._request(
+            "dnsUpdateRecord",
+            rrid=record_id,
+            domain=zone_id,  # zone_id is main_domain in NameSilo
+            rrhost=old_record.get("host"),  # host field contains subdomain
+            rrvalue=value,
+            rrtype=record_type,
+            rrttl=ttl or old_record.get("ttl"),
+        )
+
+        if response:
+            self.logger.info("DNS record updated successfully: %s", record_id)
+            return True
+        else:
+            self.logger.error("Failed to update DNS record")
+            return False

ddns/provider/noip.py

@@ -0,0 +1,101 @@
+# coding=utf-8
+"""
+No-IP (noip.com) Dynamic DNS API
+@author: GitHub Copilot
+"""
+
+from ._base import SimpleProvider, TYPE_FORM, quote
+
+
+class NoipProvider(SimpleProvider):
+    """
+    No-IP (www.noip.com) Dynamic DNS Provider
+
+    No-IP is a popular dynamic DNS service that provides simple HTTP-based
+    API for updating DNS records. This provider supports the standard
+    No-IP update protocol.
+    """
+
+    endpoint = "https://dynupdate.no-ip.com"
+    content_type = TYPE_FORM
+    accept = None  # No-IP returns plain text response
+    decode_response = False  # Response is plain text, not JSON
+
+    def _validate(self):
+        """
+        Validate authentication credentials for No-IP and update endpoint with auth
+        """
+        # Check endpoint first
+        if not self.endpoint or "://" not in self.endpoint:
+            raise ValueError("API endpoint must be defined and contain protocol")
+
+        if not self.id:
+            raise ValueError("No-IP requires username as 'id'")
+        if not self.token:
+            raise ValueError("No-IP requires password as 'token'")
+
+        # Update endpoint with URL-encoded auth credentials
+        protocol, domain = self.endpoint.split("://", 1)
+        self.endpoint = "{0}://{1}:{2}@{3}".format(
+            protocol, quote(self.id, safe=""), quote(self.token, safe=""), domain
+        )
+
+    def set_record(self, domain, value, record_type="A", ttl=None, line=None, **extra):
+        """
+        Update DNS record using No-IP Dynamic Update API
+
+        No-IP API Reference:
+        - URL: https://dynupdate.no-ip.com/nic/update
+        - Method: GET or POST
+        - Authentication: HTTP Basic Auth (username:password)
+        - Parameters:
+          - hostname: The hostname to update
+          - myip: The IP address to set (optional, uses client IP
+                  if not provided)
+
+        Response codes:
+        - good: Update successful
+        - nochg: IP address is current, no update performed
+        - nohost: Hostname supplied does not exist
+        - badauth: Invalid username/password combination
+        - badagent: Client disabled
+        - !donator: An update request was sent including a feature that
+                    is not available
+        - abuse: Username is blocked due to abuse
+        """
+        self.logger.info("%s => %s(%s)", domain, value, record_type)
+
+        # Prepare request parameters
+        params = {"hostname": domain, "myip": value}
+
+        try:
+            # Use GET request as it's the most common method for DDNS
+            # Endpoint already includes auth credentials from _validate()
+            response = self._http("GET", "/nic/update", queries=params)
+
+            if response is not None:
+                response_str = str(response).strip()
+                self.logger.info("No-IP API response: %s", response_str)
+
+                # Check for successful responses
+                if response_str.startswith("good") or response_str.startswith("nochg"):
+                    return True
+                elif response_str.startswith("nohost"):
+                    self.logger.error("Hostname %s does not exist under No-IP account", domain)
+                elif response_str.startswith("badauth"):
+                    self.logger.error("Invalid No-IP username/password combination")
+                elif response_str.startswith("badagent"):
+                    self.logger.error("No-IP client disabled")
+                elif response_str.startswith("!donator"):
+                    self.logger.error("Feature not available for No-IP free account")
+                elif response_str.startswith("abuse"):
+                    self.logger.error("No-IP account blocked due to abuse")
+                else:
+                    self.logger.error("Unexpected No-IP API response: %s", response_str)
+            else:
+                self.logger.error("Empty response from No-IP API")
+
+        except Exception as e:
+            self.logger.error("Error updating No-IP record for %s: %s", domain, e)
+
+        return False

ddns/provider/tencentcloud.py

@@ -0,0 +1,194 @@
+# coding=utf-8
+"""
+Tencent Cloud DNSPod API
+腾讯云 DNSPod API
+
+@author: NewFuture
+"""
+
+from time import gmtime, strftime, time
+
+from ._base import TYPE_JSON, BaseProvider
+from ._signature import hmac_sha256, hmac_sha256_authorization, sha256_hash
+
+
+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
+        )  # fmt: skip
+        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
+        )  # fmt: skip
+        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
+        )  # fmt: skip
+        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/fileio.py

@@ -0,0 +1,113 @@
+# -*- coding:utf-8 -*-
+"""
+File I/O utilities for DDNS with Python 2/3 compatibility
+@author: NewFuture
+"""
+
+import os
+from io import open  # Python 2/3 compatible UTF-8 file operations
+
+
+def _ensure_directory_exists(file_path):  # type: (str) -> None
+    """
+    Internal helper to ensure directory exists for the given file path
+
+    Args:
+        file_path (str): File path whose directory should be created
+
+    Raises:
+        OSError: If directory cannot be created
+    """
+    directory = os.path.dirname(file_path)
+    if directory and not os.path.exists(directory):
+        os.makedirs(directory)
+
+
+def read_file_safely(file_path, encoding="utf-8", default=None):  # type: (str, str, str|None) -> str
+    """
+    Safely read file content with UTF-8 encoding, return None if file doesn't exist or can't be read
+
+    Args:
+        file_path (str): Path to the file to read
+        encoding (str): File encoding (default: utf-8)
+
+    Returns:
+        str | None: File content or None if failed
+    """
+    try:
+        return read_file(file_path, encoding)
+    except Exception:
+        return default  # type: ignore
+
+
+def write_file_safely(file_path, content, encoding="utf-8"):  # type: (str, str, str) -> bool
+    """
+    Safely write content to file with UTF-8 encoding
+
+    Args:
+        file_path (str): Path to the file to write
+        content (str): Content to write
+        encoding (str): File encoding (default: utf-8)
+
+    Returns:
+        bool: True if write successful, False otherwise
+    """
+    try:
+        write_file(file_path, content, encoding)
+        return True
+    except Exception:
+        return False
+
+
+def read_file(file_path, encoding="utf-8"):  # type: (str, str) -> str
+    """
+    Read file content with UTF-8 encoding, raise exception if failed
+
+    Args:
+        file_path (str): Path to the file to read
+        encoding (str): File encoding (default: utf-8)
+
+    Returns:
+        str: File content
+
+    Raises:
+        IOError: If file cannot be read
+        UnicodeDecodeError: If file cannot be decoded with specified encoding
+    """
+    with open(file_path, "r", encoding=encoding) as f:
+        return f.read()
+
+
+def write_file(file_path, content, encoding="utf-8"):  # type: (str, str, str) -> None
+    """
+    Write content to file with UTF-8 encoding, raise exception if failed
+
+    Args:
+        file_path (str): Path to the file to write
+        content (str): Content to write
+        encoding (str): File encoding (default: utf-8)
+
+    Raises:
+        IOError: If file cannot be written
+        UnicodeEncodeError: If content cannot be encoded with specified encoding
+    """
+    _ensure_directory_exists(file_path)
+    with open(file_path, "w", encoding=encoding) as f:
+        f.write(content)
+
+
+def ensure_directory(file_path):  # type: (str) -> bool
+    """
+    Ensure the directory for the given file path exists
+
+    Args:
+        file_path (str): File path whose directory should be created
+
+    Returns:
+        bool: True if directory exists or was created successfully
+    """
+    try:
+        _ensure_directory_exists(file_path)
+        return True
+    except (OSError, IOError):
+        return False