hiddifypanel 10.30.9.dev0__tar.gz → 10.30.9.dev2__tar.gz

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/HISTORY.md

@@ -5,6 +5,10 @@
 
 #### New
 
+* Better ipv6 and ipv4 managemnt. 
+
+* Add quick setup steps and disable some services by default. 
+
 * Add more system api such as update usage and all configs. 
 
 #### Changes
@@ -15,6 +19,12 @@
 
 #### Fix
 
+* Xray in json config. 
+
+* Reset cache bug. 
+
+* Invalidate cache after changing settings. 
+
 * Sorting issue. 
 
 * Api uuid bug. 
@@ -31,6 +41,24 @@
 
 #### Other
 
+* Update translations. 
+
+* Allow fake domain to be empty. 
+
+* Merge branch 'main' of github.com:hiddify/Hiddify-Panel. 
+
+* Chore: update translations with Fink 🐦 
+
+* Chore: update translations with Fink 🐦 
+
+* Allow host to be empty. 
+
+* Update translations. 
+
+* Merge branch 'main' of github.com:hiddify/Hiddify-Panel. 
+
+* Update translations. 
+
 * Update. 
 
 * Update translations. 

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hiddifypanel
-Version: 10.30.9.dev0
+Version: 10.30.9.dev2
 Summary: hiddifypanel multi proxy panel
 Home-page: https://github.com/hiddify/hiddify-manager/
 Author: hiddify

hiddifypanel-10.30.9.dev2/hiddifypanel/VERSION

@@ -0,0 +1 @@
+10.30.9.dev2

hiddifypanel-10.30.9.dev2/hiddifypanel/VERSION.py

@@ -0,0 +1,3 @@
+__version__='10.30.9.dev2'
+from datetime import datetime
+__release_date__= datetime.strptime('2024-07-13','%Y-%m-%d')

hiddifypanel-10.30.9.dev2/hiddifypanel/cache.py

@@ -0,0 +1,35 @@
+from redis_cache import RedisCache, chunks, compact_dump
+import redis
+from pickle import dumps, loads
+from loguru import logger
+
+redis_client = redis.from_url('unix:///opt/hiddify-manager/other/redis/run.sock?db=0')
+
+
+class CustomRedisCache(RedisCache):
+    def __init__(self, redis_client, prefix="rc", serializer=compact_dump, deserializer=loads, key_serializer=None, support_cluster=True, exception_handler=None):
+        super().__init__(redis_client, prefix, serializer, deserializer, key_serializer, support_cluster, exception_handler)
+        self.cached_functions = set()
+
+    def cache(self, ttl=0, limit=0, namespace=None, exception_handler=None):
+        res = super().cache(ttl, limit, namespace, exception_handler)
+        self.cached_functions.add(res)
+        return res
+
+    def invalidate_all_cached_functions(self):
+        try:
+            for f in self.cached_functions:
+                f.invalidate_all()
+            logger.trace("Invalidating all cached functions")
+            chunks_gen = chunks(f'{self.prefix}*', 5000)
+            for keys in chunks_gen:
+                self.client.delete(*keys)
+            logger.trace("Successfully invalidated all cached functions")
+            return True
+        except Exception as err:
+            with logger.contextualize(error=err):
+                logger.error("Failed to invalidate all cached functions")
+            return False
+
+
+cache = CustomRedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/hiddifypanel/hutils/network/net.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Union
+from typing import List, Literal, Set, Union
 from urllib.parse import urlparse
 import urllib.request
 import ipaddress
@@ -33,17 +33,43 @@ def get_domain_ip(domain: str, retry: int = 3, version: Literal[4, 6] | None = N
 
     if not res and version != 4:
         try:
-            res = f"[{socket.getaddrinfo(domain, None, socket.AF_INET6)[0][4][0]}]"
-
-            res = res[1:-1]
+            res = f"{socket.getaddrinfo(domain, None, socket.AF_INET6)[0][4][0]}"
 
         except BaseException:
             pass
 
-    if retry <= 0 or not res:
+    if retry <= 0:
         return None
+    if not res:
+        return get_domain_ip(domain, retry=retry - 1, version=version)
+
+    return ipaddress.ip_address(res)
+
+
+def get_domain_ips(domain: str, retry: int = 3) -> Set[Union[ipaddress.IPv4Address, ipaddress.IPv6Address]]:
+    res = set()
+    if retry < 0:
+        return res
+    try:
+        _, _, ips = socket.gethostbyname_ex(domain)
+        for ip in ips:
+            res.add(ipaddress.ip_address(ip))
+    except Exception:
+        pass
+
+    try:
+        for ip in socket.getaddrinfo(domain, None, socket.AF_INET):
+            res.add(ipaddress.ip_address(ip[4][0]))
+    except BaseException:
+        pass
+
+    try:
+        for ip in socket.getaddrinfo(domain, None, socket.AF_INET6):
+            res.add(ipaddress.ip_address(ip[4][0]))
+    except BaseException:
+        pass
 
-    return ipaddress.ip_address(res) or get_domain_ip(domain, retry=retry - 1) if res else None
+    return res or get_domain_ips(domain, retry=retry - 1)
 
 
 def get_socket_public_ip(version: Literal[4, 6]) -> Union[ipaddress.IPv4Address, ipaddress.IPv6Address, None]:
@@ -85,8 +111,11 @@ def get_interface_public_ip(version: Literal[4, 6]) -> List[Union[ipaddress.IPv4
 
 
 @cache.cache(ttl=600)
-def get_ips(version: Literal[4, 6]) -> List[Union[ipaddress.IPv4Address, ipaddress.IPv6Address]]:
+def get_ips(version: Literal[4, 6] | None = None) -> List[Union[ipaddress.IPv4Address, ipaddress.IPv6Address]]:
+    if not version:
+        return [*get_ips(4), *get_ips(6)]
     addrs = []
+
     i_ips = get_interface_public_ip(version)
     if i_ips:
         addrs = i_ips

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/hiddifypanel/hutils/proxy/shared.py

@@ -130,7 +130,7 @@ def get_proxies(child_id: int = 0, only_enabled=False) -> list['Proxy']:
     if not hconfig(ConfigEnum.vmess_enable, child_id):
         proxies = [c for c in proxies if 'vmess' not in c.proto]
     if not hconfig(ConfigEnum.vless_enable, child_id):
-        proxies = [c for c in proxies if 'vless' not in c.proto]
+        proxies = [c for c in proxies if 'vless' not in c.proto or 'reality' in c.l3]
     if not hconfig(ConfigEnum.trojan_enable, child_id):
         proxies = [c for c in proxies if 'trojan' not in c.proto]
     if not hconfig(ConfigEnum.httpupgrade_enable, child_id):

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/hiddifypanel/hutils/proxy/xrayjson.py

@@ -223,8 +223,10 @@ def add_stream_settings(base: dict, proxy: dict):
     # THE CURRENT CODE WORKS BUT THE CORRECT CONDITINO SHOULD BE THIS:
     # ss['security'] == 'tls' or 'xtls' -----> ss['security'] in ['tls','xtls']
     # TODO: FIX THE CONDITION AND TEST CONFIGS ON THE CLIENT SIDE
-
-    if ss['security'] == 'tls' or 'xtls' and proxy['proto'] != ProxyProto.ss:
+    if ss['security'] == 'reality':
+        ss['network'] = proxy['transport']
+        add_reality_stream(ss, proxy)
+    elif ss['security'] == 'tls' or 'xtls' and proxy['proto'] != ProxyProto.ss:
         ss['tlsSettings'] = {
             'serverName': proxy['sni'],
             'allowInsecure': proxy['allow_insecure'],
@@ -239,9 +241,7 @@ def add_stream_settings(base: dict, proxy: dict):
             # 'cipherSuites': '', # Go lang sets
             # 'rejectUnknownSni': '', # default is false
         }
-    if ss['security'] == 'reality':
-        ss['network'] = proxy['transport']
-        add_reality_stream(ss, proxy)
+
     if proxy['l3'] == ProxyL3.kcp:
         ss['network'] = 'kcp'
         add_kcp_stream(ss, proxy)
@@ -249,7 +249,7 @@ def add_stream_settings(base: dict, proxy: dict):
     if proxy['l3'] == ProxyL3.h3_quic:
         add_quic_stream(ss, proxy)
 
-    if proxy['transport'] == 'tcp' or ss['security'] == 'reality' or (ss['security'] == 'none' and proxy['transport'] not in [ProxyTransport.httpupgrade, ProxyTransport.WS] and proxy['proto'] != ProxyProto.ss):
+    if (proxy['transport'] == 'tcp' and ss['security'] != 'reality') or (ss['security'] == 'none' and proxy['transport'] not in [ProxyTransport.httpupgrade, ProxyTransport.WS] and proxy['proto'] != ProxyProto.ss):
         ss['network'] = proxy['transport']
         add_tcp_stream(ss, proxy)
     if proxy['transport'] == ProxyTransport.h2 and ss['security'] == 'none' and ss['security'] != 'reality':

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/hiddifypanel/models/config_enum.py

@@ -243,8 +243,8 @@ class ConfigEnum(metaclass=FastEnum):
     trojan_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
     reality_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
     tcp_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
-    quic_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
-    xtls_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    quic_enable = _BoolConfigDscr(ConfigCategory.hidden, ApplyMode.apply)
+    xtls_enable = _BoolConfigDscr(ConfigCategory.hidden, ApplyMode.apply)
     h2_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
 
     db_version = _StrConfigDscr(ConfigCategory.hidden, ApplyMode.apply)

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/hiddifypanel/models/domain.py

@@ -38,7 +38,7 @@ ShowDomain = db.Table('show_domain',
 class Domain(db.Model, SerializerMixin):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0)
-    domain = db.Column(db.String(200), nullable=False, unique=False)
+    domain = db.Column(db.String(200), nullable=True, unique=False)
     alias = db.Column(db.String(200))
     sub_link_only = db.Column(db.Boolean, nullable=False, default=False)
     mode = db.Column(db.Enum(DomainType), nullable=False, default=DomainType.direct)

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/hiddifypanel/panel/admin/DomainAdmin.py

@@ -65,7 +65,7 @@ class DomainAdmin(AdminLTEModelView):
         'domain': {
             'validators': [
                 Regexp(
-                    r'^(\*\.)?([A-Za-z0-9\-\.]+\.[a-zA-Z]{2,})$',
+                    r'^(\*\.)?([A-Za-z0-9\-\.]+\.[a-zA-Z]{2,})$|^$',
                     message=__("Should be a valid domain"))]},
         "cdn_ip": {
             'validators': [
@@ -109,21 +109,24 @@ class DomainAdmin(AdminLTEModelView):
             f'</a><a href="{admin_link}" class="btn btn-xs btn-info ltr" target="_blank">{model.domain}</a></div>')
 
     def _domain_ip(view, context, model, name):
-        dip = hutils.network.get_domain_ip(model.domain)
+        dips = hutils.network.get_domain_ips(model.domain)
         # The get_domain_ip function uses the socket library, which relies on the system DNS resolver. So it may sometimes use cached data, which is not desirable
-        if not dip:
-            dip = hutils.network.resolve_domain_with_api(model.domain)
-        myip = hutils.network.get_ip(4)
-        if myip == dip and model.mode in [DomainType.direct, DomainType.sub_link_only]:
-            badge_type = ''
-        elif dip and model.mode != DomainType.direct and myip != dip:
-            badge_type = 'warning'
-        else:
-            badge_type = 'danger'
-        res = f'<span class="badge badge-{badge_type}">{dip}</span>'
-        if model.sub_link_only:
-            res += f'<span class="badge badge-success">{_("SubLink")}</span>'
-        return Markup(res)
+        # if not dips:
+        #     dip = hutils.network.resolve_domain_with_api(model.domain)
+        myips = set(hutils.network.get_ips())
+        all_res = ""
+        for dip in dips:
+            if dip in myips and model.mode in [DomainType.direct, DomainType.sub_link_only]:
+                badge_type = ''
+            elif dip and dip not in myips and model.mode != DomainType.direct:
+                badge_type = 'warning'
+            else:
+                badge_type = 'danger'
+            res = f'<span class="badge badge-{badge_type}">{dip}</span>'
+            if model.sub_link_only:
+                res += f'<span class="badge badge-success">{_("SubLink")}</span>'
+            all_res += res
+        return Markup(all_res)
 
     def _show_domains_formater(view, context, model, name):
         if not len(model.show_domains):
@@ -149,8 +152,9 @@ class DomainAdmin(AdminLTEModelView):
 
     # TODO: refactor this function
     def on_model_change(self, form, model, is_created):
-        model.domain = model.domain.lower()
-
+        model.domain = (model.domain or '').lower()
+        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':
@@ -174,7 +178,7 @@ class DomainAdmin(AdminLTEModelView):
         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
+        skip_check = "*" in model.domain or model.domain == ""
         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]
@@ -190,28 +194,30 @@ class DomainAdmin(AdminLTEModelView):
         #     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: "))
 
-        dip = hutils.network.get_domain_ip(model.domain)
+        dips = hutils.network.get_domain_ips(model.domain)
         if model.sub_link_only:
-            if dip is None:
+            if not dips:
                 raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
         elif not skip_check:
-            if dip is None:
+            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
-            domain_ip_is_same_as_panel |= dip in ipv4_list
-            for ipv6 in ipv6_list:
-                domain_ip_is_same_as_panel |= ipaddress.ip_address(dip) == ipaddress.ip_address(ipv6)
+            server_ips = [*ipv4_list, *ipv6_list]
+            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=', '.join(list(map(str, ipv4_list))), domain_ip=dip))  # type: ignore
+                    __("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=', '.join(list(map(str, ipv4_list))), domain_ip=dip))  # type: ignore
+                                      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:
@@ -219,10 +225,11 @@ class DomainAdmin(AdminLTEModelView):
 
         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")
 
         if model.mode == DomainType.fake and not model.cdn_ip:
-            model.cdn_ip = str(ipv4_list[0])
+            model.cdn_ip = str(server_ips[0])
 
         # if model.mode==DomainType.fake and model.cdn_ip!=myip:
         #     raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
@@ -230,8 +237,14 @@ class DomainAdmin(AdminLTEModelView):
         # # Update the many-to-many relationship
         if len(model.show_domains) == Domain.query.count():
             model.show_domains = []
-
-        if model.mode == DomainType.reality:
+        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(","):
@@ -240,9 +253,9 @@ class DomainAdmin(AdminLTEModelView):
                     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, ipv4_list[0]):
-                        server_asn = hutils.network.get_ip_asn(ipv4_list[0])
-                        domain_asn = hutils.network.get_ip_asn(dip)  # type: ignore
+                    if not hutils.network.is_in_same_asn(d, server_ips[0]):
+                        server_asn = hutils.network.get_ip_asn(server_ips[0])
+                        domain_asn = hutils.network.get_ip_asn(dips[0])  # 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 "")
                         hutils.flask.flash(msg, 'warning')

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/hiddifypanel/panel/admin/ProxyAdmin.py

@@ -69,7 +69,7 @@ class ProxyAdmin(FlaskView):
 
 
 def get_global_config_form(empty=False):
-    boolconfigs = BoolConfig.query.all()
+    boolconfigs = BoolConfig.query.filter(BoolConfig.child_id == Child.current().id).all()
 
     class DynamicForm(FlaskForm):
         pass

{hiddifypanel-10.30.9.dev0 → hiddifypanel-10.30.9.dev2}/hiddifypanel/panel/admin/QuickSetup.py

@@ -4,6 +4,7 @@ import uuid
 # from flask_babelex import lazy_gettext as _
 from flask import render_template, g, request
 from flask_babel import gettext as _
+from markupsafe import Markup
 import wtforms as wtf
 from flask_wtf import FlaskForm
 from flask_bootstrap import SwitchField
@@ -22,67 +23,46 @@ from hiddifypanel.models import *
 class QuickSetup(FlaskView):
     decorators = [login_required({Role.super_admin})]
 
+    def current_form(self, step=None, empty=False, next=False):
+        step = int(step or request.form.get("step") or request.args.get('step', "1"))
+        if next:
+            step = step + 1
+        form = {1: get_lang_form,
+                2: get_quick_setup_form,
+                3: get_proxy_form}
+
+        return form[step](empty=empty or next)
+
     def index(self):
         return render_template(
-            'quick_setup.html', lang_form=get_lang_form(),
-            form=get_quick_setup_form(),
-            ipv4=hutils.network.get_ip_str(4),
-            ipv6=hutils.network.get_ip_str(6),
+            'quick_setup.html',
+            form=self.current_form(),
+            # ipv4=hutils.network.get_ip_str(4),
+            # ipv6=hutils.network.get_ip_str(6),
             admin_link=admin_link(),
             show_domain_info=True)
 
     def post(self):
         if request.args.get('changepw') == "true":
             AdminUser.current_admin_or_owner().uuid = str(uuid.uuid4())
-        set_hconfig(ConfigEnum.first_setup, False)
-        quick_form = get_quick_setup_form()
-        lang_form = get_lang_form()
-        if lang_form.lang_submit.data:
-            if lang_form.validate_on_submit():
-                set_hconfig(ConfigEnum.lang, lang_form.admin_lang.data)
-                set_hconfig(ConfigEnum.admin_lang, lang_form.admin_lang.data)
-                set_hconfig(ConfigEnum.country, lang_form.country.data)
-
-                flask_babel.refresh()
-                hutils.flask.flash((_('quicksetup.setlang.success')), 'success')
-            else:
-                hutils.flask.flash((_('quicksetup.setlang.error')), 'danger')
+            db.session.commit()
 
+        set_hconfig(ConfigEnum.first_setup, False)
+        form = self.current_form()
+        if not form.validate_on_submit() or form.step.data not in ["1", "2", "3"]:
+            hutils.flask.flash(_('config.validation-error'), 'danger')
             return render_template(
-                'quick_setup.html', form=get_quick_setup_form(True),
-                lang_form=get_lang_form(),
+                'quick_setup.html', form=form,
                 admin_link=admin_link(),
                 ipv4=hutils.network.get_ip_str(4),
                 ipv6=hutils.network.get_ip_str(6),
                 show_domain_info=False)
-
-        if quick_form.validate_on_submit():
-            Domain.query.filter(Domain.domain == f'{hutils.network.get_ip_str(4)}.sslip.io').delete()
-            db.session.add(Domain(domain=quick_form.domain.data.lower(), mode=DomainType.direct))
-            set_hconfig(ConfigEnum.block_iran_sites, quick_form.block_iran_sites.data)
-            set_hconfig(ConfigEnum.decoy_domain, quick_form.decoy_domain.data)
-            # hiddify.bulk_register_configs([
-            #     # {"key": ConfigEnum.telegram_enable, "value": quick_form.enable_telegram.data == True},
-            #     # {"key": ConfigEnum.vmess_enable, "value": quick_form.enable_vmess.data == True},
-            #     # {"key": ConfigEnum.firewall, "value": quick_form.enable_firewall.data == True},
-            #     {"key": ConfigEnum.block_iran_sites, "value": quick_form.block_iran_sites.data == True},
-            #     # {"key":ConfigEnum.decoy_domain,"value":quick_form.decoy_domain.data}
-            # ])
-
-            from .Actions import Actions
-            return Actions().reinstall(domain_changed=True)
-        else:
-            hutils.flask.flash(_('config.validation-error'), 'danger')
-        return render_template(
-            'quick_setup.html', form=quick_form, lang_form=get_lang_form(True),
-            ipv4=hutils.network.get_ip_str(4),
-            ipv6=hutils.network.get_ip_str(6),
-            admin_link=admin_link(),
-            show_domain_info=False)
+        return form.post(self)
 
 
 def get_lang_form(empty=False):
     class LangForm(FlaskForm):
+        step = wtf.HiddenField(default="1")
         admin_lang = wtf.SelectField(
             _("config.admin_lang.label"), choices=[("en", _("lang.en")), ("fa", _("lang.fa")), ("pt", _("lang.pt")), ("zh", _("lang.zh")), ("ru", _("lang.ru"))],
             description=_("config.admin_lang.description"),
@@ -94,7 +74,61 @@ def get_lang_form(empty=False):
             default=hconfig(ConfigEnum.country))
         lang_submit = wtf.SubmitField(_('Submit'))
 
-    return LangForm(None)if empty else LangForm()
+        def post(self, view):
+            set_hconfig(ConfigEnum.lang, self.admin_lang.data)
+            set_hconfig(ConfigEnum.admin_lang, self.admin_lang.data)
+            set_hconfig(ConfigEnum.country, self.country.data)
+
+            flask_babel.refresh()
+            hutils.flask.flash((_('quicksetup.setlang.success')), 'success')
+
+            return render_template(
+                'quick_setup.html', form=view.current_form(next=True),
+                admin_link=admin_link(),
+                ipv4=hutils.network.get_ip_str(4),
+                ipv6=hutils.network.get_ip_str(6),
+                show_domain_info=False)
+
+    form = LangForm(None)if empty else LangForm()
+    form.step.data = "1"
+    return form
+
+
+def get_proxy_form(empty=False):
+    class ProxyForm(FlaskForm):
+        step = wtf.HiddenField(default="3")
+        description_for_fieldset = wtf.TextAreaField("", description=_(f'quicksetup.proxy_cat.description'), render_kw={"class": "d-none"})
+
+        def post(self, view):
+
+            for k, vs in self.data.items():
+                ek = ConfigEnum[k]
+                if ek != ConfigEnum.not_found:
+                    set_hconfig(ek, vs, commit=False)
+
+            db.session.commit()
+            # print(cat,vs)
+            hutils.proxy.get_proxies.invalidate_all()
+            if hutils.node.is_child():
+                hutils.node.run_node_op_in_bg(hutils.node.child.sync_with_parent, *[hutils.node.child.SyncFields.hconfigs])
+
+            from .Actions import Actions
+            return Actions().reinstall(domain_changed=True)
+    boolconfigs = BoolConfig.query.filter(BoolConfig.child_id == Child.current().id).all()
+
+    for cf in boolconfigs:
+        if cf.key.category == 'hidden':
+            continue
+        if cf.key.startswith("sub_") or cf.key.startswith("mux_"):
+            continue
+        if not cf.key.endswith("_enable") or cf.key in [ConfigEnum.hysteria_obfs_enable, ConfigEnum.tls_padding_enable]:
+            continue
+        field = SwitchField(_(f'config.{cf.key}.label'), default=cf.value, description=_(f'config.{cf.key}.description'))
+        setattr(ProxyForm, f'{cf.key}', field)
+    setattr(ProxyForm, "submit_global", wtf.fields.SubmitField(_('Submit')))
+    form = ProxyForm(None) if empty else ProxyForm()
+    form.step.data = "3"
+    return form
 
 
 def get_quick_setup_form(empty=False):
@@ -108,7 +142,9 @@ def get_quick_setup_form(empty=False):
             domains.append(d.domain)
         return domains
 
-    class QuickSetupForm(FlaskForm):
+    class BasicConfigs(FlaskForm):
+        step = wtf.HiddenField(default="2")
+        description_for_fieldset = wtf.TextAreaField("", description=_(f'quicksetup.proxy_cat.description'), render_kw={"class": "d-none"})
         domain_regex = "^([A-Za-z0-9\\-\\.]+\\.[a-zA-Z]{2,})$"
 
         domain_validators = [
@@ -116,6 +152,12 @@ def get_quick_setup_form(empty=False):
             validate_domain,
             wtf.validators.NoneOf([d.domain.lower() for d in Domain.query.all()], _("config.Domain_already_used")),
             wtf.validators.NoneOf([c.value.lower() for c in StrConfig.query.all() if "fakedomain" in c.key and c.key != ConfigEnum.decoy_domain], _("config.Domain_already_used"))]
+
+        cdn_domain_validators = [
+            wtf.validators.Regexp(f'({domain_regex})|(^$)', re.IGNORECASE, _("config.Invalid_domain")),
+            validate_domain_cdn,
+            wtf.validators.NoneOf([d.domain.lower() for d in Domain.query.all()], _("config.Domain_already_used")),
+            wtf.validators.NoneOf([c.value.lower() for c in StrConfig.query.all() if "fakedomain" in c.key and c.key != ConfigEnum.decoy_domain], _("config.Domain_already_used"))]
         domain = wtf.StringField(
             _("domain.domain"),
             domain_validators,
@@ -126,6 +168,16 @@ def get_quick_setup_form(empty=False):
                 "title": domain_validators[0].message,
                 "required": "",
                 "placeholder": "sub.domain.com"})
+
+        cdn_domain = wtf.StringField(
+            _("quicksetup.cdn_domain.label"),
+            cdn_domain_validators,
+            description=_("quicksetup.cdn_domain.description"),
+            render_kw={
+                "class": "ltr",
+                "pattern": domain_validators[0].regex.pattern,
+                "title": domain_validators[0].message,
+                "placeholder": "sub.domain.com"})
         # enable_telegram = SwitchField(_("config.telegram_enable.label"), description=_("config.telegram_enable.description"), default=hconfig(ConfigEnum.telegram_enable))
         # enable_firewall = SwitchField(_("config.firewall.label"), description=_("config.firewall.description"), default=hconfig(ConfigEnum.firewall))
         block_iran_sites = SwitchField(_("config.block_iran_sites.label"), description=_(
@@ -135,7 +187,31 @@ def get_quick_setup_form(empty=False):
             ConfigEnum.decoy_domain), validators=[wtf.validators.Regexp(domain_regex, re.IGNORECASE, _("config.Invalid_domain")), hutils.flask.validate_domain_exist])
         submit = wtf.SubmitField(_('Submit'))
 
-    return QuickSetupForm(None) if empty else QuickSetupForm()
+        def post(self, view):
+            Domain.query.filter(Domain.domain == f'{hutils.network.get_ip_str(4)}.sslip.io').delete()
+            db.session.add(Domain(domain=self.domain.data.lower(), mode=DomainType.direct))
+            if self.cdn_domain.data:
+                db.session.add(Domain(domain=self.cdn_domain.data.lower(), mode=DomainType.cdn))
+            set_hconfig(ConfigEnum.block_iran_sites, self.block_iran_sites.data)
+            set_hconfig(ConfigEnum.decoy_domain, self.decoy_domain.data)
+            # hiddify.bulk_register_configs([
+            #     # {"key": ConfigEnum.telegram_enable, "value": quick_form.enable_telegram.data == True},
+            #     # {"key": ConfigEnum.vmess_enable, "value": quick_form.enable_vmess.data == True},
+            #     # {"key": ConfigEnum.firewall, "value": quick_form.enable_firewall.data == True},
+            #     {"key": ConfigEnum.block_iran_sites, "value": quick_form.block_iran_sites.data == True},
+            #     # {"key":ConfigEnum.decoy_domain,"value":quick_form.decoy_domain.data}
+            # ])
+
+            return render_template(
+                'quick_setup.html', form=view.current_form(next=True),
+                # ipv4=hutils.network.get_ip_str(4),
+                # ipv6=hutils.network.get_ip_str(6),
+                admin_link=admin_link(),
+                show_domain_info=False)
+
+    form = BasicConfigs(None) if empty else BasicConfigs()
+    form.step.data = "2"
+    return form
 
 
 def validate_domain(form, field):
@@ -145,11 +221,26 @@ def validate_domain(form, field):
         raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
     myip = hutils.network.get_ip(4)
-    if dip and myip != dip:
+    myip6 = hutils.network.get_ip(4)
+    if dip and myip != dip and (not myip6 or myip6 != dip):
         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))
 
 
+def validate_domain_cdn(form, field):
+    domain = field.data
+    if not domain:
+        return
+    dip = hutils.network.get_domain_ip(domain)
+    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:
+        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))
+
+
 def admin_link():
     domains = Domain.get_domains()
     return hiddify.get_account_panel_link(g.account, domains[0] if len(domains)else hutils.network.get_ip_str(4))