wireless-rb 0.1.0

data/lib/wireless/h3c/parsers/display_current_configuration.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require_relative "../command_output"
+require_relative "../configuration"
+require "ctx_parser/configuration_parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 用缩进保留型号和 Radio 归属；相关命令不受支持时降低完整性。
+      class DisplayCurrentConfiguration < CtxParser::ConfigurationParser
+        include CommandOutput
+
+        private
+
+        # 声明当前命令解析器所需的换行归一化方式。
+        def output_newlines = :preserve
+
+        # 仅构建一次来源块，再将解释结果关联到行状态。
+        def parse_text(text, complete:)
+          @configuration = H3c::Configuration.new
+          @issues = []
+          read_configuration(text, comments: nil, boundaries: /\A(?:#|return)\z/)
+          recognized = cursor.lines.any? { |line| line.text == "return" }
+          blocks.each { |block| recognized = parse_block(block) || recognized }
+          @issues << { code: :missing_completeness_evidence } unless complete
+          @issues << { code: :unrecognized_configuration } unless recognized
+          CtxParser::Result.new(status: @issues.empty? ? :complete : recognized ? :partial : :failed,
+            records: recognized ? [ @configuration.data ] : [], issues: @issues)
+        end
+
+        # 未知块独立拥有其后代，不能将其放入外层作用域解释。
+        def parse_block(block, owner = nil)
+          analyze(block) { parse_setting(block, owner) }
+        rescue ArgumentError, IPAddr::InvalidAddressError
+          @issues << { code: :invalid_configuration_line, line: block.line }
+          block.children.each { |child| unrecognized_block(child) }
+          false
+        end
+
+        # 在所属父级配置作用域内解释一项支持的设置。
+        def parse_setting(block, owner)
+          line = block.text
+          selected = owner ? nested_scope(line, owner) : root_scope(line)
+          if selected
+            scope(block, selected.path) do
+              block.children.each { |child| parse_block(child, selected) }
+              selected.finish
+            end
+            true
+          elsif !owner && (match = /\Asysname (\S+)\z/.match(line))
+            @configuration.data[:global_settings][:hostname] = match[1]
+            capture(block, match[1], [ :global_settings, :hostname ])
+            true
+          elsif owner
+            apply_block(block, owner)
+          elsif /\A(?:undo )?(?:wlan|dot1x|mac-authentication)\b/i.match?(line)
+            apply_block(block, @configuration.global)
+            true
+          else
+            ignore(block)
+            false
+          end
+        end
+
+        # 返回由顶层无线配置语句选定的型号作用域。
+        def root_scope(line)
+          if (match = /\Awlan (ap-group|service-template|ap) (\S+)(?: (.+))?\z/i.match(line))
+            kind = { "ap-group" => :ap_groups, "service-template" => :service_templates, "ap" => :access_points }.fetch(match[1].downcase)
+            name, suffix = match[2], match[3]
+            raise ArgumentError, "Invalid service template" if kind == :service_templates && suffix
+            raise ArgumentError, "Missing AP model" if kind == :access_points && !suffix&.start_with?("model ")
+            @configuration.entity(kind, name, model: suffix&.delete_prefix("model "), type: suffix&.delete_prefix("type "))
+          elsif (match = /\Awlan (global-configuration|virtual-ap-group(?: \S+)?|ap-license-group|vip-client-group)\z/i.match(line))
+            key = match[1].tr("-", "_").split.first.to_sym
+            @configuration.global(key, identity: line.split[2])
+          end
+        end
+
+        # 仅选择所属配置模型允许的作用域。
+        def nested_scope(line, owner)
+          case line
+          when /\Aap-model (.+)\z/ then owner.model(Regexp.last_match(1))
+          when /\Aradio (\d+|2\.4g|5g|6g)\z/i then owner.radio(Regexp.last_match(1))
+          when /\A(?:gigabitethernet|smartrate-ethernet|ethernet|ten-gigabitethernet) \d+\z/i
+            owner.ethernet(line)
+          end
+        end
+
+        # 标记已识别叶子语句，不将其嵌套未知语法提升到父对象。
+        def apply_block(block, owner)
+          unless apply(owner, block.text, @configuration.data)
+            unrecognized_block(block)
+            return false
+          end
+
+          if owner.kind == :global
+            if /\A(?:undo )?wlan (?:client-security )?static-(black|white)list\b/.match?(block.text)
+              key = block.text.include?("static-blacklist") ? :blacklist : :whitelist
+              entries = @configuration.data[key]
+              capture(block, entries.last, [ key, entries.size - 1 ])
+            else
+              capture(block, owner.record, owner.path)
+            end
+          end
+          true
+        end
+
+        # 逐来源行记录不支持语法，并保留完整来源块。
+        def unrecognized_block(block)
+          cursor.mark(block.index, state: :unsupported)
+          @issues << { code: :unrecognized_wireless_configuration, line: block.line }
+          block.children.each { |child| unrecognized_block(child) }
+        end
+
+        # 报告未在预期作用域消费的相关子语句。
+        def unparsed_child(block) = unrecognized_block(block)
+
+        # 将已识别的无线设置应用到当前作用域记录。
+        def apply(scope, line, config)
+          owner, kind, record = scope.record, scope.kind, scope.settings
+          words = line.split
+          enabled = !line.start_with?("undo ")
+          case line
+          when /\A(?:undo )?region-code-lock enable\z/
+            return false unless kind == :global_configuration
+            record[:region_code_lock] = enabled
+          when /\Anas-id (\S+)\z/
+            return false unless kind == :global_configuration
+            record[:nas_id] = Regexp.last_match(1)
+          when /\A(?:undo )?rrop anti-bmc network (ipv4-and-ipv6-simple) enable\z/
+            return false unless kind == :ap_groups
+            (record[:rrop_anti_bmc] ||= {})[:network] = { mode: Regexp.last_match(1), enabled: enabled }
+          when /\Arrop anti-bmc default-action (deny|permit)\z/
+            return false unless kind == :ap_groups
+            (record[:rrop_anti_bmc] ||= {})[:default_action] = Regexp.last_match(1)
+          when /\Aserial-id (\S+)\z/
+            return false unless %i[access_points ap_groups].include?(kind)
+            kind == :ap_groups ? owner[:serial_ids] << words.last : record[:serial_id] = words.last
+          when /\Aap (\S+)\z/
+            return false unless kind == :ap_groups
+            owner[:ap_names] << words.last
+          when /\Avlan (\d+)\z/
+            vlan = Fields.integer(words.last, max: 4094)
+            kind == :ap_groups ? owner[:vlan_ids] << vlan : owner[:vlan_id] = vlan
+          when /\Assid (.+)\z/
+            return false unless kind == :service_templates
+            owner[:ssid] = Regexp.last_match(1)
+          when /\A(?:undo )?service-template enable\z/
+            return false unless kind == :service_templates
+            owner[:enabled] = enabled
+          when /\Aservice-template (\S+)(?: vlan (\d+))?\z/
+            return false unless kind == :radio
+            name, vlan = Regexp.last_match.captures
+            binding = { name: name, vlan_id: Fields.integer(vlan, max: 4094) }
+            previous = record[:service_templates].find { |entry| entry[:name] == name }
+            raise ArgumentError, "Conflicting template binding" if previous && previous != binding
+            record[:service_templates] |= [ binding ]
+          when /\Apreshared-key\s+.+\z/i
+            record[:has_preshared_key] = true
+          when /\Aakm mode (.+)\z/
+            record[:akm_modes] = Regexp.last_match(1).downcase.gsub("802.1x", "dot1x").split
+          when /\A(cipher-suite|security-ie) (.+)\z/
+            key = words.first == "cipher-suite" ? :cipher_suites : :security_ies
+            record[key] = words.drop(1).map(&:downcase)
+          when /\Aclient-security authentication-mode (.+)\z/
+            record[:client_security_authentication_mode] = Regexp.last_match(1).downcase
+          when /\Aclient-security (ignore-authentication|ignore-authorization)\z/
+            record[words.last.tr("-", "_").to_sym] = true
+          when /\A(dot1x|mac-authentication) domain (\S+)\z/
+            record["#{words.first.tr('-', '_')}_domain".to_sym] = words.last
+          when /\Aportal (enable method|domain|bas-ip|apply web-server|apply mac-trigger-server) (\S+)\z/
+            key, value = Regexp.last_match.captures
+            # 仅保留 Portal 是否存在；URL 与凭据不属于无线清单契约。
+            (record[:portal] ||= {})[key.tr(" -", "__").to_sym] = value.include?("://") ? true : value
+          when /\A(?:undo )?(dot1x|mac-authentication)\z/
+            record["#{Regexp.last_match(1).tr('-', '_')}_enabled".to_sym] = enabled
+          when /\Adot1x authentication-method (chap|eap|pap)\z/
+            record[:dot1x_authentication_method] = Regexp.last_match(1)
+          when /\Amac-authentication user-name-format fixed(?: account \S+)?(?: password (simple|cipher) \S+)?\z/
+            # 固定账号的明文和密文均不进入普通事实或捕获快照。
+            storage = Regexp.last_match(1)
+            record[:mac_authentication_user_name_format] = "fixed"
+            record[:mac_authentication_has_password] = !storage.nil?
+          when /\Amac-authentication user-name-format (mac-address(?: (?:with-hyphen|without-hyphen))?(?: (?:lowercase|uppercase))?)\z/
+            record[:mac_authentication_user_name_format] = Regexp.last_match(1)
+            record.delete(:mac_authentication_has_password)
+          when /\Adot1x timer (supp-timeout|tx-period) (\d+)\z/
+            (record[:dot1x_timers] ||= {})[words[2].tr("-", "_").to_sym] = Fields.integer(words.last)
+          when /\Awlan (?:client-security )?static-(black|white)list mac-address (\S+)(?: (.+))?\z/
+            kind, mac, reason = Regexp.last_match.captures
+            config[kind == "black" ? :blacklist : :whitelist] << { mac_address: Fields.mac(mac), reason: reason }
+          when /\A(?:undo )?(?:wlan )?(auto-ap|auto-persistent|band-navigation|client inspect|radio-load-balance band-navigation) enable\z/
+            record[Regexp.last_match(1).tr(" -", "__").to_sym] = enabled
+          when /\A(?:undo )?(beacon ssid-hide|bss transition-management enable)\z/
+            record[line.include?("ssid-hide") ? :ssid_hidden : :btm_enabled] = enabled
+          when /\A(client keep-alive|client-rate-limit|firmware-upgrade|radio) (enable|disable)\z/
+            key = { "client keep-alive" => :client_keep_alive, "client-rate-limit" => :client_rate_limit_enabled,
+              "firmware-upgrade" => :firmware_upgrade, "radio" => :enabled }.fetch(Regexp.last_match(1))
+            record[key] = words.last == "enable"
+          when /\A(client keep-alive interval|client max-count|client cache aging-time|bss transition-management disassociation forced timer|statistics-interval|priority|dot1x retry|wlan tcp mss) (\d+)\z/
+            key = { "client keep-alive interval" => :client_keep_alive_interval, "client max-count" => :client_max_count,
+              "client cache aging-time" => :client_cache_aging_time, "bss transition-management disassociation forced timer" => :btm_disassociation_timer,
+              "statistics-interval" => :statistics_interval, "priority" => :priority, "dot1x retry" => :dot1x_retry, "wlan tcp mss" => :tcp_mss }.fetch(Regexp.last_match(1))
+            record[key] = Fields.integer(words.last)
+          when /\A(?:description|map-configuration) (.+)\z/
+            record[words.first.tr("-", "_").to_sym] = words.drop(1).join(" ")
+          when /\Abackup-ac ip (\S+)\z/ then record[:backup_ac_ip] = Fields.ip(words.last)
+          when /\Achannel band-width (.+)\z/ then record[:channel_bandwidth] = Regexp.last_match(1)
+          when /\Achannel auto unlock\z/ then record.merge!(channel: "auto", channel_number: nil, channel_unlocked: true)
+          when /\Achannel (.+)\z/
+            record[:channel] = Regexp.last_match(1)
+            record[:channel_number] = Fields.channel(record[:channel])
+          when /\Amax-power (\d+(?:\.\d+)?)\z/ then record[:max_power] = Fields.number(words.last)
+          when /\Aclient-rate-limit (inbound|outbound) mode (\S+) cir (\d+)\z/
+            (record[:client_rate_limit] ||= {})[words[1].to_sym] = { mode: words[3], cir_bps: Fields.integer(words.last) * 1000 }
+          when /\Arate (mandatory|supported|disabled|multicast) (.+)\z/
+            (record[:rates] ||= {})[words[1].to_sym] = words[1] == "multicast" ? words.drop(2).join(" ") : words.drop(2).map { |word| Fields.number(word) }
+          when /\Aoption client (reject|reconnect) enable rssi (-?\d+(?:\.\d+)?)\z/
+            (record[:client_options] ||= {})[words[2].to_sym] = Fields.number(words.last)
+          when /\Asacp anti-sticky enable(?: rssi (-?\d+(?:\.\d+)?))? interval (\d+)\z/
+            signal, interval = Regexp.last_match.captures
+            record[:anti_sticky] = { enabled: true, rssi: Fields.number(signal), interval: Fields.integer(interval) }
+          when /\Apacket-filter name (\S+) (inbound|outbound)\z/
+            (record[:packet_filters] ||= {})[words.last.to_sym] = words[2]
+          when /\A(?:client forwarding-location|wlan image-load filepath|wlan fast-forwarding mode|led-mode) (\S+)\z/
+            key = { "client" => :forwarding_location, "wlan image-load" => :image_load_filepath,
+              "wlan fast-forwarding" => :fast_forwarding_mode, "led-mode" => :led_mode }
+            record[key.fetch(words.first == "wlan" ? words.take(2).join(" ") : words.first)] = words.last
+          when /\A(local|member) ip (\S+)\z/
+            words.first == "local" ? record[:local_ip] = Fields.ip(words.last) : (record[:member_ips] ||= []) << Fields.ip(words.last)
+          when /\Aclient-mac (\S+)\z/ then (record[:mac_addresses] ||= []) << Fields.mac(words.last)
+          when "wlan tunnel-preempt enable" then record[:tunnel_preempt] = true
+          when "broadcast-probe reply disable" then record[:broadcast_probe_reply] = false
+          when "radar-detect disable" then record[:radar_detect_disabled] = true
+          when "calibrate-channel self-decisive enable all" then record[:calibrate_channel] = true
+          when "calibrate-power self-decisive enable all" then record[:calibrate_power] = true
+          when "ap-license-synchronization enable" then record[:license_synchronization] = true
+          else return false
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/wireless/h3c/parsers/display_dot1x_connection.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../authentication_parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 解析 display dot1x connection 报告的会话。
+      class DisplayDot1xConnection < AuthenticationParser
+      end
+    end
+  end
+end

data/lib/wireless/h3c/parsers/display_lldp_neighbor_information_verbose.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # AP LLDP 端点与控制器资产区分处理，并要求明确的零邻居证据。
+      class DisplayLldpNeighborInformationVerbose < Parser
+        DETAILS = [ "system description", "port description", "port vlan id", "vlan id", "maximum frame size",
+          "chassis type", "port type", "port id type", "management address type", "update time", "time to live",
+          "system capabilities supported", "system capabilities enabled", "management address interface type",
+          "management address interface id", "management address oid", "link aggregation supported", "link aggregation enabled",
+          "aggregation port id", "auto-negotiation supported", "auto-negotiation enabled", "opermau", "power port class",
+          "pse power supported", "pse power enabled", "pse pairs control ability", "power pairs", "port power classification",
+          "power type", "power source", "power priority", "pd requested power value", "pse allocated power value" ].freeze
+
+        private
+
+        # 解释当前命令记录，保留不完整行诊断。
+        def parse_text(text, complete:)
+          records, issues = [], []
+          current = nil
+          local = nil
+          description_indent = nil
+          flush = lambda do
+            if current && current.values_at(:local_interface, :remote_chassis_id, :remote_interface).all? { |value| value && !value.strip.empty? }
+              records << current
+            elsif current
+              issues << { code: :incomplete_neighbor }
+            end
+            current = nil
+          end
+          text.lines.each_with_index do |line, index|
+            row = line.strip
+            next if row.empty? || /\A[-=]+\z/.match?(row)
+            if description_indent && line[/\A\s*/].size > description_indent
+              current[:details][:system_description] += "\n#{row}"
+              next
+            end
+            description_indent = nil
+            if (match = /\ALLDP neighbor-information of port \d+\[(.+?)\]\s*:?\z/i.match(row))
+              flush.call
+              local = match[1]
+            elsif /\ALLDP neighbor index\s*:/i.match?(row)
+              flush.call
+              current = { local_interface: local }
+            elsif /\A(?:LLDP agent\s+[^:]+:|No (?:LLDP )?neighbors|(?:Total|Number of neighbors).*:\s*\d+)\s*\z/i.match?(row)
+              next
+            elsif (match = /\A([^:]+):\s*(.*?)\z/.match(row))
+              label, raw = match.captures
+              label = label.strip.downcase
+              current ||= { local_interface: local }
+              case label
+              when "chassis id" then current[:remote_chassis_id] = raw.downcase
+              when "port id" then current[:remote_interface] = raw
+              when "system name" then current[:remote_name] = Fields.value(raw)
+              when "management address"
+                begin
+                  current[:management_address] = Fields.ip(Fields.value(raw))
+                rescue IPAddr::InvalidAddressError, ArgumentError
+                  issues << { code: :invalid_management_address, line: index + 1 }
+                end
+              when "port vlan id(pvid)" then (current[:details] ||= {})[:port_vlan_id] = raw
+              when *DETAILS
+                (current[:details] ||= {})[label.tr(" ", "_").to_sym] = raw
+                description_indent = line[/\A\s*/].size if label == "system description"
+              else issues << { code: :unrecognized_field, line: index + 1 }
+              end
+            else
+              issues << { code: :unrecognized_line, line: index + 1 }
+            end
+          end
+          flush.call
+          total = /(?:total(?: (?:LLDP )?neighbors)?|number of neighbors)[^\n:]*:\s*(\d+)\s*$/i.match(text)&.[](1)&.to_i
+          total ||= 0 if /\ANo (?:LLDP )?neighbors\s*$/i.match?(text.strip)
+          Fields.result(records, issues: issues, complete: complete, total: total,
+            identity: %i[local_interface remote_chassis_id remote_interface])
+        end
+      end
+    end
+  end
+end

data/lib/wireless/h3c/parsers/display_mac_authentication_connection.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../authentication_parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 解析 display mac-authentication connection 报告的会话。
+      class DisplayMacAuthenticationConnection < AuthenticationParser
+      end
+    end
+  end
+end

data/lib/wireless/h3c/parsers/display_wlan_ap_all_verbose.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "../verbose_parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 单条回显同时包含 AP 清单及其嵌套 Radio 清单。
+      class DisplayWlanApAllVerbose < VerboseParser
+        AP_FIELDS = { "ap id" => :ap_id, "ap group name" => :group_name, "state" => :operational_status,
+          "model" => :model, "mac address" => :mac_address, "ip address" => :management_ip,
+          "serial id" => :serial, "s/w version" => :os_version, "client count" => :client_count,
+          "number of clients" => :client_count, "online clients" => :client_count, "online time" => :uptime_seconds }.freeze
+        RADIO_FIELDS = { "admin state" => :admin_status, "state" => :admin_status, "radio type" => :protocol,
+          "type" => :protocol, "channel" => :channel, "channel usage(%)" => :utilization,
+          "channel usage" => :utilization, "noise floor" => :noise_dbm, "channel bandwidth" => :channel_width,
+          "operating bandwidth" => :channel_width }.freeze
+        AP_DETAILS = [ "backup type", "ready-for-switchover", "system uptime", "region code", "region code lock",
+          "udp control port number", "udp data port number", "h/w version", "boot version", "usb state", "power level",
+          "power info", "poe status", "description", "priority", "echo interval", "echo count", "keepalive interval",
+          "discovery-response wait-time", "statistics report interval", "fragment size (data)", "fragment size (control)",
+          "mac type", "tunnel mode", "discovery type", "retransmission count", "retransmission interval", "firmware upgrade",
+          "sent control packets", "received control packets", "echo requests", "lost echo responses", "average echo delay",
+          "last reboot reason", "last reboot reason (ac check)", "latest ip address", "current ac ip", "tunnel down reason",
+          "connection count", "backup ipv4", "backup ipv6", "ctrl-tunnel encryption", "ctrl-tunnel encryption state",
+          "data-tunnel encryption", "data-tunnel encryption state", "led mode", "remote configuration", "energysaving level",
+          "ap type", "map file", "forwarding mode", "ble mode", "capwap data-tunnel status" ].freeze
+        RADIO_DETAILS = [ "basic bssid", "bssid", "antenna type", "client dot11ac-only", "client dot11n-only",
+          "secondary channel offset", "secondary channel mode", "short gi for 20mhz", "short gi for 40mhz",
+          "short gi for 80mhz", "short gi for 160mhz", "mimo", "green-energy-management", "a-msdu", "a-mpdu", "ldpc", "stbc",
+          "max power", "operational rate", "distance", "ani", "fragmentation threshold", "beacon interval", "protection threshold",
+          "long retry threshold", "short retry threshold", "frame aging time in cache", "protection mode", "mu-txbf", "su-txbf",
+          "continuous mode", "client dot11ax-only", "ofdma random access rus", "he ofdma random access rus", "channel width set",
+          "dl-ofdma", "ul-ofdma", "ul-mu-mimo", "bss-color", "twt negotiation", "radar-detect switch", "ht protection mode",
+          "atf", "preamble type", "operational vht-mcs set", "mandatory", "supported", "multicast", "operational ht mcs set",
+          "disabled", "operational he-mcs set" ].freeze
+
+        private
+
+        # 解释当前命令记录，保留不完整行诊断。
+        def parse_text(text, complete:)
+          access_points, radios, issues = [], [], []
+          ap = radio = nil
+          tokens(text, issues).each do |label, raw, line|
+            if label == "ap name"
+              ap = { name: raw }
+              access_points << ap
+              radio = nil
+            elsif (match = /\Aradio (\d+)\z/.match(label))
+              radio = { ap_name: ap&.fetch(:name), radio_id: match[1] }
+              radios << radio
+            else
+              owner = radio && RADIO_FIELDS.key?(label) ? radio : ap
+              mapping = owner.equal?(radio) && radio ? RADIO_FIELDS : AP_FIELDS
+              details = AP_DETAILS.include?(label) ? ap : RADIO_DETAILS.include?(label) ? radio : nil
+              assign_field(owner, mapping, label, raw, issues, line, details: details)
+            end
+          end
+          invalid = access_points.reject { |record| !record[:name].nil? && !record[:name].strip.empty? }
+          issues << { code: :invalid_identity } if invalid.any?
+          valid_aps = access_points - invalid
+          issues << { code: :duplicate_identity } if CtxParser::Records.new(valid_aps, identity: [ :name ]).duplicates?
+          radios.reject! do |record|
+            missing = record[:ap_name].nil? || record[:ap_name].strip.empty?
+            issues << { code: :invalid_identity } if missing
+            missing
+          end
+          total = count(text, "APs")
+          issues << { code: :count_mismatch, expected: total, parsed: valid_aps.size } if total && total != valid_aps.size
+          # AP 总数证明共享命令的覆盖范围，不代表 Radio 数量。
+          radio_total = total && total == valid_aps.size ? radios.size : nil
+          CtxParser::ResultSet.new(results: {
+            access_points: Fields.result(valid_aps, issues: issues.dup, complete: complete, total: total, identity: [ :name ]),
+            radios: Fields.result(radios, issues: issues.dup, complete: complete, total: radio_total, identity: %i[ap_name radio_id])
+          })
+        end
+      end
+    end
+  end
+end

data/lib/wireless/h3c/parsers/display_wlan_ap_model_all.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../verbose_parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 型号能力与发现的 AP 资产及 Radio 分开保存。
+      class DisplayWlanApModelAll < VerboseParser
+        MODEL_FIELDS = { "alias" => :alias, "vendor name" => :vendor_name, "vendor id" => :vendor_id,
+          "license weight" => :license_weight, "license type" => :license_type, "radio count" => :radio_count, "type" => :type }.freeze
+        RADIO_FIELDS = { "mode" => :modes, "default mode" => :default_mode, "bss count" => :bss_count }.freeze
+        VERSION_FIELDS = { "software version" => :software_version, "default software version" => :default_software_version,
+          "image name" => :image_name }.freeze
+        INTEGER_FIELDS = %i[vendor_id license_weight license_type radio_count bss_count].freeze
+
+        private
+
+        # 解释当前命令记录，保留不完整行诊断。
+        def parse_text(text, complete:)
+          records, issues = [], []
+          lines = text.lines
+          model = section = nil
+          mapping = MODEL_FIELDS
+          tokens(text, issues).each do |label, raw, line|
+            safely(issues, line) do
+              if label == "ap model"
+                raise ArgumentError, "Missing AP model" unless raw
+                model = { model: raw, radios: [], versions: [] }
+                records << model
+                section, mapping = model, MODEL_FIELDS
+              elsif model && (match = /\Aradio (\d+)\z/.match(label)) && raw.nil?
+                section = { radio_id: Fields.integer(match[1]).to_s }
+                model[:radios] << section
+                mapping = RADIO_FIELDS
+              elsif model && label == "version support list" && raw.nil?
+                section, mapping = nil, VERSION_FIELDS
+              elsif model && (match = /\Ahardware version (.+)\z/.match(label)) && raw.nil?
+                section = { hardware_version: lines[line - 1].strip[/\AHardware version (.+?)\s*:/i, 1] }
+                model[:versions] << section
+                mapping = VERSION_FIELDS
+              elsif section && (field = mapping[label])
+                raise ArgumentError, "Duplicate model field" if section.key?(field)
+                section[field] = model_value(field, raw)
+              else
+                issues << { code: :unrecognized_field, line: line }
+              end
+            end
+          end
+          records.each { |record| validate_model(record, issues) }
+          Fields.result(records, issues: issues, complete: complete, total: count(text, "AP models"), identity: [ :model ])
+        end
+
+        # 根据声明字段类型归一化型号能力值。
+        def model_value(field, raw)
+          return Fields.integer(raw) if INTEGER_FIELDS.include?(field)
+          return raw&.split(/\s*,\s*/) if field == :modes
+
+          field == :type ? raw&.sub(/\A:\s*/, "") : raw
+        end
+
+        # 输出可作为权威事实的型号能力前，先校验其有效性。
+        def validate_model(record, issues)
+          radios = record[:radios]
+          if record[:radio_count].nil? || record[:radio_count] != radios.size ||
+              radios.any? { |radio| %i[modes default_mode bss_count].any? { |key| radio[key].nil? } }
+            issues << { code: :incomplete_model, model: record[:model] }
+          end
+          if record[:versions].any? { |version| VERSION_FIELDS.values.any? { |key| version[key].nil? } }
+            issues << { code: :incomplete_version, model: record[:model] }
+          end
+          [ [ radios, :radio_id ], [ record[:versions], :hardware_version ] ].each do |rows, key|
+            issues << { code: :duplicate_identity, model: record[:model] } if rows.map { |row| row[key] }.uniq.size != rows.size
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wireless/h3c/parsers/display_wlan_bss_all_verbose.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../session_parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 同时接受以 BSSID 或 AP 名称开头的 BSS 块。
+      class DisplayWlanBssAllVerbose < SessionParser
+        MAPPING = COMMON_FIELDS.merge("service template" => :profile, "service template name" => :profile,
+          "state" => :operational_status, "client count" => :client_count, "number of clients" => :client_count,
+          "online clients" => :client_count).freeze
+        SECURITY = [ "security mode", "akm mode", "cipher suite", "bss id", "user authentication mode", "tx bssid", "ft status", "btm status", "mlo status" ].freeze
+        IDENTITY = [ :bssid ].freeze
+        COUNT = "BSSs?".freeze
+
+        private
+
+        # 返回当前命令格式中用于开始新记录的字段。
+        def start_label(fields)
+          first = fields.find { |label,| label == "bssid" || label == "ap name" }
+          "ap name" if first&.first == "ap name"
+        end
+
+        # 要求具备关联当前记录所需的稳定身份字段。
+        def valid_identity?(record)
+          super && record[:ap_name] && !record[:ap_name].strip.empty? && !record[:radio_id].nil?
+        end
+
+        # 保留 BSS 安全字段，其余字段委派给共享会话解析器。
+        def assign_session_field(record, label, raw, issues, line)
+          if SECURITY.include?(label)
+            (record[:security] ||= {})[label.tr(" -", "__").to_sym] = raw
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wireless/h3c/parsers/display_wlan_client_security_block_mac.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 解析明确的阻断客户端记录及空列表证据。
+      class DisplayWlanClientSecurityBlockMac < Parser
+        private
+
+        # 解释当前命令记录，保留不完整行诊断。
+        def parse_text(text, complete:)
+          records, issues = [], []
+          text.lines.each_with_index do |line, index|
+            row = line.strip
+            next if row.empty? || /\A[-=]+\z/.match?(row) || /\A(?:No blocked clients|MAC address\b.*|(?:Client )?block list|Blocked clients|Total.*:\s*\d+)\z/i.match?(row)
+            if (match = /\A((?:[0-9a-f]{4}-){2}[0-9a-f]{4}|(?:[0-9a-f]{2}:){5}[0-9a-f]{2})\s*(.*?)\z/i.match(row))
+              records << { mac_address: Fields.mac(match[1]), reason: match[2] }
+            else
+              issues << { code: :unrecognized_line, line: index + 1 }
+            end
+          end
+          total = /Total[^\n:]*:\s*(\d+)/i.match(text)&.[](1)&.to_i
+          total = 0 if /\ANo blocked clients\s*$/i.match?(text.strip)
+          Fields.result(records, issues: issues, complete: complete, total: total, identity: [ :mac_address ])
+        end
+      end
+    end
+  end
+end

data/lib/wireless/h3c/parsers/display_wlan_client_verbose.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../session_parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 解析客户端会话，区分相对 RSSI 与实测 dBm。
+      class DisplayWlanClientVerbose < SessionParser
+        MAPPING = COMMON_FIELDS.merge("mac address" => :client_mac, "ipv4 address" => :client_ip,
+          "ip address" => :client_ip, "ipv6 address" => :client_ipv6, "username" => :username,
+          "channel" => :channel, "frequency band" => :band, "state" => :operational_status, "status" => :operational_status,
+          "wireless mode" => :protocol, "channel bandwidth" => :channel_width, "sm power save mode" => :power_save,
+          "sm power save" => :power_save, "qos mode" => :qos, "online time" => :uptime_seconds,
+          "authentication method" => :auth_method, "security mode" => :security, "akm mode" => :akm,
+          "cipher suite" => :cipher).freeze
+        DETAILS = [ "authorization car", "authorization acl id", "authorization user profile", "key derivation",
+          "forwarding policy name", "ft status", "sae pwe method", "authorization user group name", "authorization dynamic acl name",
+          "mlo status", "user authentication mode", "wpa3 status", "pmf status", "block ack", "supported vht-mcs set",
+          "supported ht mcs set", "supported rates", "supported he-mcs set", "sleep count", "short gi for 40mhz",
+          "short gi for 80mhz", "short gi for 160/80+80mhz", "stbc tx capability", "beamformee sts capability",
+          "number of sounding dimensions", "su beamformee capability", "mu beamformee capability", "5g 40and80mhz channel bandwidth",
+          "5g 160mhz channel bandwidth", "5g 80+80mhz channel bandwidth", "20/40 bss coexistence management",
+          "2.4g 40mhz channel bandwidth", "short gi for 20mhz", "stbc rx capability", "ldpc rx capability",
+          "ofdma random access rus", "twt scheduled", "listen interval", "aid", "roam status", "btm mode", "radio slice(last effecive)", "speed" ].freeze
+        IDENTITY = [ :client_mac ].freeze
+        COUNT = "clients".freeze
+
+        private
+
+        # 归一化成对客户端速率，区分相对 RSSI 与实测 dBm。
+        def assign_session_field(record, label, raw, issues, line)
+          case label
+          when "rx/tx rate"
+            safely(issues, line) { record[:rx_rate_mbps], record[:tx_rate_mbps] = Fields.rates(raw) }
+          when "rssi"
+            safely(issues, line) do
+              signal = Fields.number(raw, unit: "dBm")
+              record[:signal_dbm] = signal if signal&.negative?
+              record[:rssi] = signal.round if signal&.positive?
+            end
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end