hiddifypanel 10.80.0.dev13__py3-none-any.whl → 10.80.0.dev15__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.80.0.dev13
+10.80.0.dev15

hiddifypanel/VERSION.py

@@ -2,5 +2,5 @@ import importlib.metadata
 from datetime import datetime
 
 __version__ = importlib.metadata.version(__package__ or __name__)
-__release_time__= datetime.strptime('2024-11-16T22:55:11','%Y-%m-%dT%H:%M:%S')
+__release_time__= datetime.strptime('2024-12-08T23:50:34','%Y-%m-%dT%H:%M:%S')
 is_released_version=True

hiddifypanel/hutils/proxy/__init__.py

@@ -3,3 +3,4 @@ from . import xray
 from . import xrayjson
 from . import singbox
 from . import clash
+from . import wireguard

hiddifypanel/hutils/proxy/clash.py

@@ -33,7 +33,7 @@ def to_clash(proxy, meta_or_normal):
 
     if proxy['l3'] in ["kcp", ProxyL3.h3_quic]:
         return {'name': name, 'msg': f"clash does not support {proxy['l3']}", 'type': 'debug'}
-    if proxy['transport'] in [ProxyTransport.splithttp, ProxyTransport.httpupgrade]:
+    if proxy['transport'] in [ProxyTransport.xhttp, ProxyTransport.httpupgrade]:
         return {'name': name, 'msg': f"clash does not support {proxy['transport']}", 'type': 'debug'}
     # if proxy['proto'] in [Proxy.shado]:
 
@@ -44,7 +44,7 @@ def to_clash(proxy, meta_or_normal):
             return {'name': name, 'msg': f"clash does not support {proxy['proto']}", 'type': 'debug'}
         if proxy['proto'] in ["vless", 'tuic', 'hysteria2']:
             return {'name': name, 'msg': f"{proxy['proto']} not supported in clash", 'type': 'debug'}
-        if proxy['transport'] in ["shadowtls", "splithttp"]:
+        if proxy['transport'] in ["shadowtls", "xhttp"]:
             return {'name': name, 'msg': f"{proxy['transport']} not supported in clash", 'type': 'debug'}
     if proxy['l3'] == ProxyL3.tls_h2 and proxy['proto'] in [ProxyProto.vmess, ProxyProto.vless] and proxy['dbe'].cdn == ProxyCDN.direct:
         return {'name': name, 'msg': "bug tls_h2 vmess and vless in clash meta", 'type': 'warning'}

hiddifypanel/hutils/proxy/shared.py

@@ -134,8 +134,8 @@ def get_proxies(child_id: int = 0, only_enabled=False) -> list['Proxy']:
         proxies = [c for c in proxies if 'trojan' not in c.proto]
     if not hconfig(ConfigEnum.httpupgrade_enable, child_id):
         proxies = [c for c in proxies if ProxyTransport.httpupgrade not in c.transport]
-    if not hconfig(ConfigEnum.splithttp_enable, child_id):
-        proxies = [c for c in proxies if ProxyTransport.splithttp not in c.transport]
+    if not hconfig(ConfigEnum.xhttp_enable, child_id):
+        proxies = [c for c in proxies if ProxyTransport.xhttp not in c.transport]
     if not hconfig(ConfigEnum.ws_enable, child_id):
         proxies = [c for c in proxies if ProxyTransport.WS not in c.transport]
     # if not hconfig(ConfigEnum.xtls_enable, child_id):
@@ -189,7 +189,7 @@ def get_valid_proxies(domains: list[Domain]) -> list[dict]:
             noDomainProxies = False
             if proxy.proto in [ProxyProto.ssh, ProxyProto.wireguard]:
                 noDomainProxies = True
-            if proxy.proto in [ProxyProto.ss] and proxy.transport not in [ProxyTransport.grpc, ProxyTransport.h2, ProxyTransport.WS, ProxyTransport.httpupgrade, ProxyTransport.splithttp]:
+            if proxy.proto in [ProxyProto.ss] and proxy.transport not in [ProxyTransport.grpc, ProxyTransport.h2, ProxyTransport.WS, ProxyTransport.httpupgrade, ProxyTransport.xhttp]:
                 noDomainProxies = True
             options = []
             key = f'{proxy.proto}{proxy.transport}{proxy.cdn}{proxy.l3}'
@@ -413,9 +413,9 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
         base['path'] = f'/{path[base["proto"]]}{hconfigs[ConfigEnum.path_httpupgrade]}'
         base["host"] = domain
         return base
-    if proxy.transport in [ProxyTransport.splithttp]:
-        base['transport'] = 'splithttp'
-        base['path'] = f'/{path[base["proto"]]}{hconfigs[ConfigEnum.path_splithttp]}'
+    if proxy.transport in [ProxyTransport.xhttp]:
+        base['transport'] = 'xhttp'
+        base['path'] = f'/{path[base["proto"]]}{hconfigs[ConfigEnum.path_xhttp]}'
         # if 0 and 'h2' in base['alpn'] or 'h3' in base['alpn']:
         #     base['path'] += "2"
         # else:

hiddifypanel/hutils/proxy/singbox.py

@@ -47,7 +47,7 @@ def configs_as_json(domains: list[Domain], **kwargs) -> str:
 def is_xray_proxy(proxy: dict):
     if g.user_agent.get('is_hiddify_prefere_xray'):
         return True
-    if proxy['transport'] == ProxyTransport.splithttp:
+    if proxy['transport'] == ProxyTransport.xhttp:
         return True
     return False
 

hiddifypanel/hutils/proxy/wireguard.py

@@ -0,0 +1,34 @@
+
+def generate_wireguard_config(proxy: dict) -> str:
+    """
+    Generates a WireGuard configuration from a given proxy dictionary.
+
+    Args:
+        proxy (dict): Dictionary containing WireGuard and proxy details.
+
+    Returns:
+        str: A WireGuard configuration string.
+    """
+    name=f'{proxy["extra_info"]} {proxy["name"]}'
+    addrs = f"{proxy['wg_ipv4']}/32"
+    if proxy['wg_ipv6']:
+        addrs += f", {proxy['wg_ipv6']}/128"
+    config = f"""[Interface]
+# Name = {name}
+Address= {addrs}
+PrivateKey = {proxy["wg_pk"]}
+MTU = {proxy.get("mtu", 1380)}
+DNS = {proxy.get("dns", "1.1.1.1")}
+
+[Peer]
+# Name = Public Peer for {name}
+Endpoint = {proxy["server"]}:{proxy["port"]}
+PublicKey = {proxy["wg_server_pub"]}
+PresharedKey = {proxy['wg_psk']}
+#PersistentKeepalive = {proxy.get("keep_alive", 25)}
+"""
+
+#Address = {proxy.get("wg_ipv4", "0.0.0.0/32")}
+#AllowedIPs = {proxy.get("allowed_ips", "0.0.0.0/0")}
+
+    return config

hiddifypanel/hutils/proxy/xray.py

@@ -126,10 +126,10 @@ def to_link(proxy: dict) -> str | dict:
         baseurl += "&encryption=none"
     if proxy.get('fingerprint', 'none') != 'none':
         baseurl += "&fp=" + proxy['fingerprint']
-    if proxy.get('transport') in {ProxyTransport.splithttp}:
+    if proxy.get('transport') in {ProxyTransport.xhttp}:
         baseurl += "&core=xray"
     if proxy['l3'] != 'quic':
-        if proxy.get('l3') != ProxyL3.reality and (proxy.get('transport') in {ProxyTransport.tcp, ProxyTransport.httpupgrade, ProxyTransport.splithttp}) and proxy['proto'] in [ProxyProto.vless, ProxyProto.trojan]:
+        if proxy.get('l3') != ProxyL3.reality and (proxy.get('transport') in {ProxyTransport.tcp, ProxyTransport.httpupgrade, ProxyTransport.xhttp}) and proxy['proto'] in [ProxyProto.vless, ProxyProto.trojan]:
             baseurl += '&headerType=http'
         else:
             baseurl += '&headerType=None'

hiddifypanel/hutils/proxy/xrayjson.py

@@ -262,9 +262,9 @@ def add_stream_settings(base: dict, proxy: dict):
     if proxy['transport'] == ProxyTransport.httpupgrade:
         ss['network'] = proxy['transport']
         add_httpupgrade_stream(ss, proxy)
-    if proxy['transport'] == ProxyTransport.splithttp:
+    if proxy['transport'] == ProxyTransport.xhttp:
         ss['network'] = proxy['transport']
-        add_splithttp_stream(ss, proxy)
+        add_xhttp_stream(ss, proxy)
     if proxy['transport'] == 'ws':
         ss['network'] = proxy['transport']
         add_ws_stream(ss, proxy)
@@ -338,8 +338,8 @@ def add_httpupgrade_stream(ss: dict, proxy: dict):
     }
 
 
-def add_splithttp_stream(ss: dict, proxy: dict):
-    ss['splithttpSettings'] = {
+def add_xhttp_stream(ss: dict, proxy: dict):
+    ss['xhttpSettings'] = {
         'path': proxy['path'],
         'host': proxy['host'],
         "headers": {

hiddifypanel/models/config_enum.py

@@ -239,7 +239,7 @@ class ConfigEnum(metaclass=FastEnum):
     ws_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply_config)
     grpc_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply_config)
     httpupgrade_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply_config)
-    splithttp_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply_config)
+    xhttp_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply_config)
 
     vless_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply_config)
     trojan_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply_config)
@@ -262,7 +262,7 @@ class ConfigEnum(metaclass=FastEnum):
     path_v2ray = _StrConfigDscr(ConfigCategory.hidden, ApplyMode.apply_config, hide_in_virtual_child=True)  # deprecated
     path_ss = _StrConfigDscr(ConfigCategory.hidden, ApplyMode.apply_config, hide_in_virtual_child=True)
 
-    path_splithttp = _StrConfigDscr(ConfigCategory.too_advanced, ApplyMode.apply_config, hide_in_virtual_child=True)
+    path_xhttp = _StrConfigDscr(ConfigCategory.too_advanced, ApplyMode.apply_config, hide_in_virtual_child=True)
     path_httpupgrade = _StrConfigDscr(ConfigCategory.too_advanced, ApplyMode.apply_config, hide_in_virtual_child=True)
     path_ws = _StrConfigDscr(ConfigCategory.too_advanced, ApplyMode.apply_config, hide_in_virtual_child=True)
     path_tcp = _StrConfigDscr(ConfigCategory.too_advanced, ApplyMode.apply_config, hide_in_virtual_child=True)

hiddifypanel/models/proxy.py

@@ -20,7 +20,7 @@ class ProxyTransport(StrEnum):
     tcp = auto()
     ssh = auto()
     httpupgrade = auto()
-    splithttp = auto()
+    xhttp = auto()
     custom = auto()
     shadowsocks = auto()
 

hiddifypanel/panel/admin/AdminstratorAdmin.py

@@ -143,19 +143,18 @@ class AdminstratorAdmin(AdminLTEModelView):
         """)
 
     def _max_active_users_formatter(view, context, model, name):
-
-        actives = [u for u in model.recursive_users_query().all() if u.is_active]
-        u = len(actives)
+        """Optimized user count formatter using database queries"""
+        active_count = model.recursive_users_query().filter(User.is_active == True).count()
         if model.mode == AdminMode.super_admin:
-            return f"{u} / ∞"
+            return f"{active_count} / ∞"
         t = model.max_active_users
-        rate = round(u * 100 / (t + 0.000001))
-        state = "danger" if u >= t else ('warning' if rate > 80 else 'success')
-        color = "#ff7e7e" if u >= t else ('#ffc107' if rate > 80 else '#9ee150')
+        rate = round(active_count * 100 / (t + 0.000001))
+        color = "#ff7e7e" if active_count >= t else ('#ffc107' if rate > 80 else '#9ee150')
+        
         return Markup(f"""
         <div class="progress progress-lg position-relative" style="min-width: 100px;">
           <div class="progress-bar progress-bar-striped" role="progressbar" style="width: {rate}%;background-color: {color};" aria-valuenow="{rate}" aria-valuemin="0" aria-valuemax="100"></div>
-              <span class='badge position-absolute' style="left:auto;right:auto;width: 100%;font-size:1em">{u} {_('user.home.usage.from')} {t}</span>
+              <span class='badge position-absolute' style="left:auto;right:auto;width: 100%;font-size:1em">{active_count} {_('user.home.usage.from')} {t}</span>
 
         </div>
         """)

hiddifypanel/panel/admin/DomainAdmin.py

@@ -16,6 +16,7 @@ from hiddifypanel.panel import hiddify, custom_widgets
 from .adminlte import AdminLTEModelView
 from hiddifypanel import hutils
 
+from loguru import logger
 from flask import current_app
 # Define a custom field type for the related domains
 
@@ -152,132 +153,164 @@ class DomainAdmin(AdminLTEModelView):
 
     # TODO: refactor this function
     def on_model_change(self, form, model, is_created):
-        model.domain = (model.domain or '').lower()
+        # Sanitize domain input
+        model.domain = (model.domain or '').lower().strip()
+        
+        # Basic validation
         if model.domain == '' and model.mode != DomainType.fake:
             raise ValidationError(_("domain.empty.allowed_for_fake_only"))
-        configs = get_hconfigs()
-        for c in configs:
-            if "domain" in c and c not in [ConfigEnum.decoy_domain, ConfigEnum.reality_fallback_domain] and c.category != 'hidden':
-                if model.domain == configs[c]:
-                    raise ValidationError(_("You have used this domain in: ") + _(f"config.{c}.label"))
-
-        for td in Domain.query.filter(Domain.mode == DomainType.reality, Domain.domain != model.domain).all():
-            # print(td)
-            if td.servernames and (model.domain in td.servernames.split(",")):
-                raise ValidationError(_("You have used this domain in: ") + _(f"config.reality_server_names.label") + td.domain)
-
-        if is_created and Domain.query.filter(Domain.domain == model.domain, Domain.child_id == model.child_id).count() > 1:
-            raise ValidationError(_("You have used this domain in: "))
 
+        self._validate_not_used_before(model,is_created)
         ipv4_list = hutils.network.get_ips(4)
         ipv6_list = hutils.network.get_ips(6)
+        server_ips = [*ipv4_list, *ipv6_list]
 
-        if not ipv4_list and not ipv6_list:
+        if not server_ips:
             raise ValidationError(_("Couldn't find your ip addresses"))
 
+        # Validate domain based on mode
         if "*" in model.domain and model.mode not in [DomainType.cdn, DomainType.auto_cdn_ip]:
             raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
-        skip_check = "*" in model.domain or model.domain == ""
+        cloudflare_updated=self._update_cloudflare(model, ipv4_list,ipv6_list)
+        
+        if not (cloudflare_updated or "*" in model.domain or model.domain == ""):
+            self._validate_domain_ips(model, server_ips)
+
+        # Handle CDN IP settings
+        if model.mode == DomainType.direct and model.cdn_ip:
+            model.cdn_ip = ""
+            raise ValidationError(_("Specifying CDN IP is only valid for CDN mode"))
+            
+        if model.mode == DomainType.fake and not model.cdn_ip:
+            model.cdn_ip = str(server_ips[0])
+            
+        if model.cdn_ip:
+            try:
+                hutils.network.auto_ip_selector.get_clean_ip(str(model.cdn_ip))
+            except Exception:
+                raise ValidationError(_("Error in auto cdn format"))
+                    
+        # Update show domains
+        if len(model.show_domains) == Domain.query.count():
+            model.show_domains = []
+                
+        # Handle mode-specific settings
+        if model.mode == DomainType.old_xtls_direct and not hconfig(ConfigEnum.xtls_enable):
+            set_hconfig(ConfigEnum.xtls_enable, True)
+            hutils.proxy.get_proxies().invalidate_all()
+        elif model.mode == DomainType.reality:
+            self._validate_reality_settings(model, server_ips)
+                
+            # Signal config update if needed
+        old_db_domain = Domain.by_domain(model.domain)
+        if is_created or not old_db_domain or old_db_domain.mode != model.mode:
+            # return hiddify.reinstall_action(complete_install=False, domain_changed=True)
+            hutils.flask.flash_config_success(restart_mode=ApplyMode.apply_config, domain_changed=True)
+
+            
+
+    def _update_cloudflare(self, model, ipv4_list,ipv6_list):
         if hconfig(ConfigEnum.cloudflare) and model.mode not in [DomainType.fake, DomainType.relay, DomainType.reality]:
             try:
                 proxied = model.mode in [DomainType.cdn, DomainType.auto_cdn_ip]
-                hutils.network.cf_api.add_or_update_dns_record(model.domain, str(ipv4_list[0]), "A", proxied=proxied)
+                if ipv4_list:
+                    hutils.network.cf_api.add_or_update_dns_record(model.domain, str(ipv4_list[0]), "A", proxied=proxied)
                 if ipv6_list:
                     hutils.network.cf_api.add_or_update_dns_record(model.domain, str(ipv6_list[0]), "AAAA", proxied=proxied)
-
-                skip_check = True
+                return True
             except Exception as e:
                 raise ValidationError(__("cloudflare.error") + f' {e}')
-        # elif model.mode==DomainType.auto_cdn_ip:
-        # if model.alias and not model.alias.replace("_", "").isalnum():
-        #     hutils.flask.flash(__("Using alias with special charachters may cause problem in some clients like FairVPN."), 'warning')
-            # raise ValidationError(_("You have to add your cloudflare api key to use this feature: "))
+        return False
 
-        dips = hutils.network.get_domain_ips(model.domain)
-        server_ips = [*ipv4_list, *ipv6_list]
-        if model.sub_link_only:
-            if not dips:
-                raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
-        elif not skip_check:
-            if not dips:
-                raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
-
-            domain_ip_is_same_as_panel = False
-
-            for mip in server_ips:
-                domain_ip_is_same_as_panel |= mip in dips
-            server_ips_str = ', '.join(list(map(str, server_ips)))
-            dips_str = ', '.join(list(map(str, dips)))
-
-            if model.mode == DomainType.direct and not domain_ip_is_same_as_panel:
-                # hutils.flask.flash(__(f"Domain IP={dip} is not matched with your ip={', '.join(list(map(str, ipv4_list)))} which is required in direct mode"),category='error')
-                raise ValidationError(
-                    __("Domain IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode", server_ip=server_ips_str, domain_ip=dips_str))  # type: ignore
-
-            if domain_ip_is_same_as_panel and model.mode in [DomainType.cdn, DomainType.relay, DomainType.fake, DomainType.auto_cdn_ip]:
-                #     # hutils.flask.flash(__(f"In CDN mode, Domain IP={dip} should be different to your ip={', '.join(list(map(str, ipv4_list)))}"), 'warning')
-                raise ValidationError(__("In CDN mode, Domain IP=%(domain_ip)s should be different to your ip=%(server_ip)s",
-                                      server_ip=server_ips_str, domain_ip=dips_str))  # type: ignore
-
-            # if model.mode in [DomainType.ss_faketls, DomainType.telegram_faketls]:
-            #     if len(Domain.query.filter(Domain.mode==model.mode and Domain.id!=model.id).all())>0:
-            #         ValidationError(f"another {model.mode} is exist")
-
-        model.domain = model.domain.lower()
-        if model.mode == DomainType.direct and model.cdn_ip:
-            model.cdn_ip = ""
-            raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
+    def _validate_reality_settings(self, model, server_ips):
+        """Validate REALITY protocol settings with proper error handling"""
+        if not hconfig(ConfigEnum.reality_enable):
+            set_hconfig(ConfigEnum.reality_enable, True)
+            hutils.proxy.get_proxies().invalidate_all()
 
-        if model.mode == DomainType.fake and not model.cdn_ip:
-            model.cdn_ip = str(server_ips[0])
+        model.servernames = (model.servernames or model.domain).lower().strip()
+        domains_to_check = set()
+        for v in [model.domain, model.servernames]:
+            domains_to_check.update(d.strip() for d in v.split(",") if d.strip())
 
-        # if model.mode==DomainType.fake and model.cdn_ip!=myip:
-        #     raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
+        for d in domains_to_check:
+            # Check REALITY compatibility
+            if not hutils.network.is_domain_reality_friendly(d):
+                raise ValidationError(_("Domain is not REALITY friendly!") + f' {d}')
 
-        # # Update the many-to-many relationship
-        if len(model.show_domains) == Domain.query.count():
-            model.show_domains = []
-        if model.mode == DomainType.old_xtls_direct:
-            if not hconfig(ConfigEnum.xtls_enable):
-                set_hconfig(ConfigEnum.xtls_enable, True)
-                hutils.proxy.get_proxies().invalidate_all()
-        elif model.mode == DomainType.reality:
-            if not hconfig(ConfigEnum.reality_enable):
-                set_hconfig(ConfigEnum.reality_enable, True)
-                hutils.proxy.get_proxies().invalidate_all()
-            model.servernames = (model.servernames or model.domain).lower()
-            for v in set([model.domain, model.servernames]):
-                for d in v.split(","):
-                    if not d:
-                        continue
-                    if not hutils.network.is_domain_reality_friendly(d):  # the minimum requirement for the REALITY protocol is to have tls1.3 and h2
-                        raise ValidationError(_("Domain is not REALITY friendly!") + f' {d}')
-
-                    if not hutils.network.is_in_same_asn(d, server_ips[0]):
-                        dip = next(iter(dips))
+            try:
+                if not hutils.network.is_in_same_asn(d, server_ips[0]):
+                    domain_ips = hutils.network.get_domain_ips(d)
+                    if domain_ips:
+                        dip = next(iter(domain_ips))
                         server_asn = hutils.network.get_ip_asn(server_ips[0])
-                        domain_asn = hutils.network.get_ip_asn(dip)  # type: ignore
-                        msg = _("domain.reality.asn_issue") + \
-                            (f"<br> Server ASN={server_asn}<br>{d}_ASN={domain_asn}" if server_asn or domain_asn else "")
+                        domain_asn = hutils.network.get_ip_asn(dip)
+                        msg = _("domain.reality.asn_issue")
+                        if server_asn or domain_asn:
+                            msg += f"<br> Server ASN={server_asn}<br>{d}_ASN={domain_asn}"
                         hutils.flask.flash(msg, 'warning')
+            except Exception as e:
+                logger.warning(f"ASN check failed for domain {d}: {str(e)}")
 
-            for d in model.servernames.split(","):
-                if not hutils.network.fallback_domain_compatible_with_servernames(model.domain, d):
-                    msg = _("REALITY Fallback domain is not compaitble with server names!") + f' {d} != {model.domain}'
-                    hutils.flask.flash(msg, 'warning')
+        # Check fallback compatibility
+        for d in model.servernames.split(","):
+            if d.strip() and not hutils.network.fallback_domain_compatible_with_servernames(model.domain, d):
+                msg = _("REALITY Fallback domain is not compatible with server names!") + f' {d} != {model.domain}'
+                hutils.flask.flash(msg, 'warning')
 
-        if (model.cdn_ip):
-            try:
-                hutils.network.auto_ip_selector.get_clean_ip(str(model.cdn_ip))
-            except BaseException:
-                raise ValidationError(_("Error in auto cdn format"))
 
-        old_db_domain = Domain.by_domain(model.domain)
-        if is_created or not old_db_domain or old_db_domain.mode != model.mode:
-            # return hiddify.reinstall_action(complete_install=False, domain_changed=True)
-            hutils.flask.flash_config_success(restart_mode=ApplyMode.apply_config, domain_changed=True)
+    def _validate_not_used_before(self, model,is_created):
+        configs = get_hconfigs()
+        for c in configs:
+            if "domain" in c and c not in [ConfigEnum.decoy_domain, ConfigEnum.reality_fallback_domain] and c.category != 'hidden':
+                if model.domain == configs[c]:
+                    raise ValidationError(_("You have used this domain in: ") + _(f"config.{c}.label"))
+
+        for td in Domain.query.filter(Domain.mode == DomainType.reality, Domain.domain != model.domain).all():
+            # print(td)
+            if td.servernames and (model.domain in td.servernames.split(",")):
+                raise ValidationError(_("You have used this domain in: ") + _(f"config.reality_server_names.label") + td.domain)
 
+        if is_created and Domain.query.filter(Domain.domain == model.domain, Domain.child_id == model.child_id).count() > 1:
+            raise ValidationError(_("You have used this domain in: "))
+
+    def _validate_domain_ips(self, model, server_ips):
+        """Validate domain IP resolution and matching"""
+        
+        # Skip validation for wildcard or empty domains
+        if model.domain.startswith('*') or not model.domain:
+            return True
+        
+        # Resolve domain IPs with timeout
+        try:
+            dips = hutils.network.get_domain_ips(model.domain, timeout=10)
+        except Exception as e:
+            logger.error(f"Error resolving domain {model.domain}: {str(e)}")
+            raise ValidationError(_("Domain cannot be resolved! Please check DNS settings"))
+        
+        # Validate resolution success
+        if not dips:
+            raise ValidationError(_("Domain cannot be resolved! Please check DNS settings"))
+        
+        # Check IP matching based on mode
+        domain_ip_matches_server = any(ip in dips for ip in server_ips)
+        server_ips_str = ', '.join(map(str, server_ips))
+        dips_str = ', '.join(map(str, dips))
+    
+        if not domain_ip_matches_server and model.mode in [DomainType.direct]:
+            raise ValidationError(
+                __("Domain IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode",
+                    server_ip=server_ips_str, domain_ip=dips_str))
+                
+        if domain_ip_matches_server and model.mode in [DomainType.cdn, DomainType.relay, DomainType.fake, DomainType.auto_cdn_ip]:
+            raise ValidationError(
+                __("In CDN mode, Domain IP=%(domain_ip)s should be different to your ip=%(server_ip)s",
+                    server_ip=server_ips_str, domain_ip=dips_str))
+                
+        return True
+    
+        
     # def after_model_change(self,form, model, is_created):
     #     if model.show_domains.count==0:
     #         db.session.bulk_save_objects(ShowDomain(model.id,model.id))

hiddifypanel/panel/admin/QuickSetup.py

@@ -72,7 +72,7 @@ def get_lang_form(empty=False):
             default=hconfig(ConfigEnum.admin_lang))
         # lang=wtf.SelectField(_("config.lang.label"),choices=[("en",_("lang.en")),("fa",_("lang.fa"))],description=_("config.lang.description"),default=hconfig(ConfigEnum.lang))
         country = wtf.SelectField(
-            _("config.country.label"), choices=[("ir", _("Iran")), ("zh", _("China")), ("other", "Others")],
+            _("config.country.label"), choices=[("ir", _("Iran")), ("zh", _("China")), ("ru", _("Russia")),  ("other", "Others")],
             description=_("config.country.description"),
             default=hconfig(ConfigEnum.country))
         lang_submit = wtf.SubmitField(_('Submit'))
@@ -251,11 +251,11 @@ def validate_domain(form, field):
     if dip is None:
         raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
-    myip = hutils.network.get_ip(4)
-    myip6 = hutils.network.get_ip(4)
-    if dip and myip != dip and (not myip6 or myip6 != dip):
+    myips = hutils.network.get_ips()
+      # Fixed: Changed from get_ip(4) to get_ip(6)
+    if dip not in myips:
         raise ValidationError(_("Domain (%(domain)s)-> IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode",
-                              server_ip=myip, domain_ip=dip, domain=domain))
+                              server_ip=myips, domain_ip=dip, domain=domain))
 
 
 def validate_domain_cdn(form, field):
@@ -266,10 +266,10 @@ def validate_domain_cdn(form, field):
     if dip is None:
         raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
-    myip = hutils.network.get_ip(4)
-    if myip == dip:
+    myips = hutils.network.get_ips()
+    if dip in myips:
         raise ValidationError(_("In CDN mode, Domain IP=%(domain_ip)s should be different to your ip=%(server_ip)s",
-                              server_ip=myip, domain_ip=dip, domain=domain))
+                              server_ip=myips, domain_ip=dip, domain=domain))
 
 
 def admin_link():