diff --git a/extensions/Servers/Proxmox/views/components/layout.blade.php b/extensions/Servers/Proxmox/views/components/layout.blade.php index 276efa50a..dfcd021ae 100644 --- a/extensions/Servers/Proxmox/views/components/layout.blade.php +++ b/extensions/Servers/Proxmox/views/components/layout.blade.php @@ -12,8 +12,7 @@ $pollAttribute = $statusPolling ? 'wire:poll' . $pollSuffix . '="loadVmStatus"' : ''; @endphp -
-
+
@if($server->status === 'active') + <\/h3> +

Live bandwidth • Updates every 30 seconds<\/p> + <\/div> -

+ d="M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z"><\/path> + <\/svg> + Graph<\/span> + <\/button> + <\/div>
@@ -1416,20 +1416,20 @@
- - Download - 0 B/s -
+ d="M7 16a4 4 0 01-.88-7.903A5 5 0 1115.9 6L16 6a5 5 0 011 9.9M9 19l3 3m0 0l3-3m-3 3V10"><\/path> + <\/svg> + Download<\/span> + 0 B/s<\/span> + <\/div>
- Peak: - 0 B/s -
-
+ Peak: <\/span> + 0 B/s<\/span> + <\/div> + <\/div>
-
-
-
+
<\/div> + <\/div> + <\/div>
@@ -1437,44 +1437,44 @@
- - Upload - 0 B/s -
+ d="M7 16a4 4 0 01-.88-7.903A5 5 0 1115.9 6L16 6a5 5 0 011 9.9M15 13l-3-3m0 0l-3 3m3-3v12"><\/path> + <\/svg> + Upload<\/span> + 0 B/s<\/span> + <\/div>
- Peak: - 0 B/s -
-
+ Peak: <\/span> + 0 B/s<\/span> + <\/div> + <\/div>
-
-
-
+
<\/div> + <\/div> + <\/div>
- -
-
+ <\/canvas> + <\/div> + <\/div>
-

Combined

-

0 B/s

-
+

Combined<\/p> +

0 B/s<\/p> + <\/div>

-

Total In

-

0 MB

-
+

Total In<\/p> +

0 MB<\/p> + <\/div>

-

Total Out

-

0 MB

-
-
-
+

Total Out<\/p> +

0 MB<\/p> + <\/div> + <\/div> + <\/div> `; }; @@ -1608,10 +1608,10 @@

- -

No network data available

-
+ d="M9.172 16.172a4 4 0 015.656 0M9 10h.01M15 10h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"><\/path> + <\/svg> +

No network data available<\/p> + <\/div> `; return; } @@ -1879,11 +1879,11 @@

- -

Failed to load network data

-

${error.message}

-
+ d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"><\/path> + <\/svg> +

Failed to load network data<\/p> +

${error.message}<\/p> + <\/div> `; } } finally { @@ -2200,4 +2200,4 @@ @endonce - \ No newline at end of file + diff --git a/extensions/Servers/Proxmox/views/statistics.blade.php b/extensions/Servers/Proxmox/views/statistics.blade.php index 07a2cc4f4..745ebf042 100644 --- a/extensions/Servers/Proxmox/views/statistics.blade.php +++ b/extensions/Servers/Proxmox/views/statistics.blade.php @@ -4121,25 +4121,25 @@ const formatStateDescription = (overview, meaning, scenarios, notes = null) => { let html = '

'; if (overview) { - html += `

Overview

${overview}

`; + html += `

Overview<\/h4>

${overview}<\/p><\/div>`; } if (meaning) { - html += `

What This Means

${meaning}

`; + html += `

What This Means<\/h4>

${meaning}<\/p><\/div>`; } if (scenarios) { - html += `

Common Scenarios

${scenarios}
`; + html += `

Common Scenarios<\/h4>${scenarios}<\/div>`; } if (notes) { - html += `

Additional Notes

${notes}

`; + html += `

Additional Notes<\/h4>

${notes}<\/p><\/div>`; } - html += '

'; + html += '<\/div>'; return html; }; // Direction descriptions mapping window.getDirectionDescription = function(direction) { if (!direction || typeof direction !== 'string') { - return '

Unknown direction

'; + return '

Unknown direction<\/p><\/div>'; } const directionUpper = direction.toUpperCase(); @@ -4147,12 +4147,12 @@ 'INBOUND': formatStateDescription( 'Inbound traffic represents network connections coming TO your server. This means data is being sent from an external source (another computer, device, or service) and arriving at your server.', 'All directions are shown from your server\'s perspective. "Inbound" means the connection is coming IN to your server - external clients or services are connecting to your server.', - '

Inbound connections typically include:

  • External clients connecting to your server (e.g., web browsers accessing your website)
  • API requests from external services
  • File uploads or data being sent to your server
  • Remote connections (SSH, RDP) to your server
  • Email being received by your mail server
  • DNS queries to your DNS server
' + '

Inbound connections typically include:<\/p>

  • External clients connecting to your server (e.g., web browsers accessing your website)<\/li>
  • API requests from external services<\/li>
  • File uploads or data being sent to your server<\/li>
  • Remote connections (SSH, RDP) to your server<\/li>
  • Email being received by your mail server<\/li>
  • DNS queries to your DNS server<\/li><\/ul>' ), 'OUTBOUND': formatStateDescription( 'Outbound traffic represents network connections going FROM your server. This means data is being sent from your server to an external destination (another computer, device, or service).', 'All directions are shown from your server\'s perspective. "Outbound" means the connection is going OUT from your server - your server is initiating connections to external systems.', - '

    Outbound connections typically include:

    • Your server making requests to external APIs or services
    • Database connections to remote servers
    • Your server downloading files or updates
    • Your server initiating connections to other systems
    • DNS queries from your server to external DNS servers
    • Email being sent from your mail server
    ' + '

    Outbound connections typically include:<\/p>

    • Your server making requests to external APIs or services<\/li>
    • Database connections to remote servers<\/li>
    • Your server downloading files or updates<\/li>
    • Your server initiating connections to other systems<\/li>
    • DNS queries from your server to external DNS servers<\/li>
    • Email being sent from your mail server<\/li><\/ul>' ), }; @@ -4174,73 +4174,73 @@ 'TCP': formatStateDescription( 'TCP (Transmission Control Protocol) is a connection-oriented protocol that provides reliable, ordered, and error-checked delivery of data between applications.', 'TCP establishes a connection before data transfer and ensures data integrity through acknowledgments and retransmissions. It guarantees that data is delivered in order and without errors.', - '

      Common uses include:

      • Web browsing (HTTP/HTTPS)
      • Email (SMTP, IMAP, POP3)
      • File transfers (FTP)
      • Remote access (SSH, RDP)
      • Database connections
      • API communications
      ', + '

      Common uses include:<\/p>

      • Web browsing (HTTP/HTTPS)<\/li>
      • Email (SMTP, IMAP, POP3)<\/li>
      • File transfers (FTP)<\/li>
      • Remote access (SSH, RDP)<\/li>
      • Database connections<\/li>
      • API communications<\/li><\/ul>', 'TCP is the most commonly used transport protocol on the Internet and provides reliable communication at the cost of slightly higher overhead compared to UDP.' ), 'UDP': formatStateDescription( 'UDP (User Datagram Protocol) is a connectionless protocol that provides fast, low-overhead data transmission without guarantees of delivery, ordering, or duplicate protection.', 'UDP does not establish connections before sending data and does not provide reliability features like acknowledgments or retransmissions. It prioritizes speed over reliability.', - '

        Common uses include:

        • DNS queries
        • Video streaming
        • Online gaming
        • VoIP (Voice over IP)
        • Real-time applications
        • DHCP (Dynamic Host Configuration Protocol)
        ', + '

        Common uses include:<\/p>

        • DNS queries<\/li>
        • Video streaming<\/li>
        • Online gaming<\/li>
        • VoIP (Voice over IP)<\/li>
        • Real-time applications<\/li>
        • DHCP (Dynamic Host Configuration Protocol)<\/li><\/ul>', 'UDP is ideal for applications where speed is more important than reliability, or where occasional packet loss is acceptable.' ), 'ICMP': formatStateDescription( 'ICMP (Internet Control Message Protocol) is a network layer protocol used for diagnostic and control purposes.', 'ICMP is used by network devices to send error messages and operational information. It is essential for network troubleshooting and does not carry application data.', - '

          Common uses include:

          • Ping (echo request/reply) for connectivity testing
          • Traceroute for path discovery
          • Error reporting (destination unreachable, time exceeded)
          • Network diagnostics
          ', + '

          Common uses include:<\/p>

          • Ping (echo request/reply) for connectivity testing<\/li>
          • Traceroute for path discovery<\/li>
          • Error reporting (destination unreachable, time exceeded)<\/li>
          • Network diagnostics<\/li><\/ul>', 'ICMP is a stateless protocol and does not use connection states like TCP or UDP. It operates at the network layer alongside IP.' ), 'ICMPV6': formatStateDescription( 'ICMPv6 (Internet Control Message Protocol version 6) is the IPv6 equivalent of ICMP, used for error reporting and diagnostic functions in IPv6 networks.', 'ICMPv6 includes additional features beyond what ICMP provides for IPv4, including integrated support for address configuration and network discovery.', - '

            Key features include:

            • Neighbor Discovery Protocol (NDP) for IPv6
            • Path MTU Discovery for IPv6
            • Router discovery and configuration
            • Error reporting and diagnostics
            ', + '

            Key features include:<\/p>

            • Neighbor Discovery Protocol (NDP) for IPv6<\/li>
            • Path MTU Discovery for IPv6<\/li>
            • Router discovery and configuration<\/li>
            • Error reporting and diagnostics<\/li><\/ul>', 'ICMPv6 is essential for IPv6 network operation and provides functions that in IPv4 are handled by multiple protocols (ARP, ICMP, etc.).' ), 'IGMP': formatStateDescription( 'IGMP (Internet Group Management Protocol) is a communications protocol used by hosts and adjacent routers to establish multicast group memberships.', 'IGMP is used to manage multicast group membership on IPv4 networks, allowing hosts to join and leave multicast groups and routers to track which hosts are members of which groups.', - '

              Common uses include:

              • Multicast video streaming
              • Software distribution to multiple hosts
              • Network discovery protocols
              • IP television (IPTV)
              ', + '

              Common uses include:<\/p>

              • Multicast video streaming<\/li>
              • Software distribution to multiple hosts<\/li>
              • Network discovery protocols<\/li>
              • IP television (IPTV)<\/li><\/ul>', 'IGMP enables efficient one-to-many communication by allowing routers to forward multicast traffic only to networks with active group members.' ), 'ESP': formatStateDescription( 'ESP (Encapsulating Security Payload) is a protocol used in IPsec to provide confidentiality, data origin authentication, connectionless integrity, and anti-replay protection for IP packets.', 'ESP encrypts the payload (data) of IP packets and provides authentication to ensure data integrity and origin verification.', - '

                Common uses include:

                • VPN connections (Virtual Private Networks)
                • Secure site-to-site connections
                • Encrypted network tunnels
                • Secure remote access
                ', + '

                Common uses include:<\/p>

                • VPN connections (Virtual Private Networks)<\/li>
                • Secure site-to-site connections<\/li>
                • Encrypted network tunnels<\/li>
                • Secure remote access<\/li><\/ul>', 'ESP is part of the IPsec suite and can be used alone or in combination with AH (Authentication Header) for enhanced security.' ), 'AH': formatStateDescription( 'AH (Authentication Header) is a protocol used in IPsec to provide connectionless integrity, data origin authentication, and optional anti-replay protection for IP packets.', 'AH authenticates IP packets to ensure they have not been modified in transit and verifies the origin of the data. Unlike ESP, AH does not provide encryption.', - '

                  Common uses include:

                  • VPN connections where integrity is critical
                  • Secure network tunnels
                  • Site-to-site connections
                  • Combined with ESP for enhanced security
                  ', + '

                  Common uses include:<\/p>

                  • VPN connections where integrity is critical<\/li>
                  • Secure network tunnels<\/li>
                  • Site-to-site connections<\/li>
                  • Combined with ESP for enhanced security<\/li><\/ul>', 'AH provides authentication without encryption, making it useful when you need to verify data integrity but encryption is not required or is handled separately.' ), 'GRE': formatStateDescription( 'GRE (Generic Routing Encapsulation) is a tunneling protocol used to encapsulate a wide variety of network layer protocols inside virtual point-to-point links over an Internet Protocol network.', 'GRE creates tunnels that can carry many different protocols, allowing you to transport protocols that would not normally be routable over an IP network.', - '

                    Common uses include:

                    • VPN tunnels
                    • Site-to-site connections
                    • Multicast tunneling
                    • Carrying non-IP protocols over IP networks
                    • Network virtualization
                    ', + '

                    Common uses include:<\/p>

                    • VPN tunnels<\/li>
                    • Site-to-site connections<\/li>
                    • Multicast tunneling<\/li>
                    • Carrying non-IP protocols over IP networks<\/li>
                    • Network virtualization<\/li><\/ul>', 'GRE is a simple, lightweight tunneling protocol that adds minimal overhead and is widely supported across network equipment.' ), 'SCTP': formatStateDescription( 'SCTP (Stream Control Transmission Protocol) is a transport layer protocol that provides reliable, message-oriented communication with congestion control and multi-homing support.', 'SCTP combines features of TCP (reliability, congestion control) with some UDP characteristics (message-oriented) and adds unique features like multi-homing and message bundling.', - '

                      Common uses include:

                      • Telecommunications signaling (SIGTRAN)
                      • WebRTC data channels
                      • Database replication
                      • Applications requiring multi-homed connections
                      ', + '

                      Common uses include:<\/p>

                      • Telecommunications signaling (SIGTRAN)<\/li>
                      • WebRTC data channels<\/li>
                      • Database replication<\/li>
                      • Applications requiring multi-homed connections<\/li><\/ul>', 'SCTP is less common than TCP or UDP but provides advantages for specific use cases, especially in telecommunications and applications requiring multiple network paths.' ), 'DCCP': formatStateDescription( 'DCCP (Datagram Congestion Control Protocol) is a message-oriented transport layer protocol that provides congestion control for unreliable datagrams.', 'DCCP provides congestion control (like TCP) but without reliability guarantees (like UDP), making it suitable for applications that need congestion control but can tolerate packet loss.', - '

                        Common uses include:

                        • Streaming media applications
                        • Online gaming where congestion control is needed
                        • Real-time applications requiring flow control
                        ', + '

                        Common uses include:<\/p>

                        • Streaming media applications<\/li>
                        • Online gaming where congestion control is needed<\/li>
                        • Real-time applications requiring flow control<\/li><\/ul>', 'DCCP is relatively uncommon and provides a middle ground between TCP (reliable but slower) and UDP (fast but no congestion control).' ), 'OSPF': formatStateDescription( 'OSPF (Open Shortest Path First) is a routing protocol used in IP networks to determine the best path for data packets based on link-state routing algorithms.', 'OSPF is an Interior Gateway Protocol (IGP) that routers use to exchange routing information and build a map of the network topology to calculate optimal routes.', - '

                          Key features include:

                          • Link-state routing for efficient path calculation
                          • Fast convergence after network changes
                          • Support for variable-length subnet masks (VLSM)
                          • Authentication support for security
                          ', + '

                          Key features include:<\/p>

                          • Link-state routing for efficient path calculation<\/li>
                          • Fast convergence after network changes<\/li>
                          • Support for variable-length subnet masks (VLSM)<\/li>
                          • Authentication support for security<\/li><\/ul>', 'OSPF is commonly used in enterprise networks and internet service provider networks for internal routing.' ), 'EIGRP': formatStateDescription( 'EIGRP (Enhanced Interior Gateway Routing Protocol) is a Cisco proprietary routing protocol that combines the benefits of distance-vector and link-state routing protocols.', 'EIGRP is an advanced Interior Gateway Protocol that uses Diffusing Update Algorithm (DUAL) to provide fast convergence and efficient use of bandwidth.', - '

                            Key features include:

                            • Fast convergence
                            • Low bandwidth usage
                            • Support for multiple network layer protocols
                            • Route summarization capabilities
                            ', + '

                            Key features include:<\/p>

                            • Fast convergence<\/li>
                            • Low bandwidth usage<\/li>
                            • Support for multiple network layer protocols<\/li>
                            • Route summarization capabilities<\/li><\/ul>', 'EIGRP is primarily used in Cisco-based networks and provides efficient routing with minimal network overhead.' ), }; @@ -4262,18 +4262,18 @@ if (state === '0:0' || state.trim() === '0:0') { return `
                              -

                              Overview

                              -

                              0:0 indicates that there is no state level data for this connection. This state is typically only found on ICMP (Internet Control Message Protocol) states, since ICMP does not have state levels like other protocols (TCP, UDP, etc.).

                              -
                              +

                              Overview<\/h4> +

                              0:0 indicates that there is no state level data for this connection. This state is typically only found on ICMP (Internet Control Message Protocol) states, since ICMP does not have state levels like other protocols (TCP, UDP, etc.).<\/p> + <\/div>

                              -

                              What This Means

                              -

                              ICMP is a stateless protocol used for diagnostic and control purposes such as ping (echo request/reply), traceroute, or error reporting. The "0:0" format means there is no connection state tracking because ICMP packets are connectionless and don't establish sessions like TCP connections do.

                              -
                              +

                              What This Means<\/h4> +

                              ICMP is a stateless protocol used for diagnostic and control purposes such as ping (echo request/reply), traceroute, or error reporting. The "0:0" format means there is no connection state tracking because ICMP packets are connectionless and don't establish sessions like TCP connections do.<\/p> + <\/div>

                              -

                              Is This Normal?

                              -

                              Yes, this is completely normal for ICMP traffic and simply indicates the protocol's stateless nature. ICMP connections will always show 0:0 since they don't use connection states.

                              -
                              -

                              `; +

                              Is This Normal?<\/h4> +

                              Yes, this is completely normal for ICMP traffic and simply indicates the protocol's stateless nature. ICMP connections will always show 0:0 since they don't use connection states.<\/p> + <\/div> + <\/div>`; } // Handle colon-separated states (e.g., "TIME_WAIT:TIME_WAIT" or "SINGLE:MULTIPLE") @@ -4286,27 +4286,27 @@ (primaryState === 'MULTIPLE' && secondaryState === 'SINGLE')) { return `

                              -

                              Overview

                              -

                              SINGLE:MULTIPLE (or MULTIPLE:SINGLE) is commonly observed with DNS queries and other UDP-based services. According to pfSense documentation, this pattern indicates asymmetric state tracking for UDP connections.

                              -
                              +

                              Overview<\/h4> +

                              SINGLE:MULTIPLE (or MULTIPLE:SINGLE) is commonly observed with DNS queries and other UDP-based services. According to pfSense documentation, this pattern indicates asymmetric state tracking for UDP connections.<\/p> + <\/div>

                              -

                              State Format Explanation

                              +

                              State Format Explanation<\/h4>
                                -
                              • The part before the colon represents the connection state for the source side
                                • -
                              • The part after the colon represents the connection state for the destination side
                                • -
                              • SINGLE means the firewall has observed a single packet from that direction
                                • -
                              • MULTIPLE means the firewall has observed multiple packets from that direction
                                • -
                              -

                              +
                            • The part before the colon represents the connection state for the source side<\/li> +
                            • The part after the colon represents the connection state for the destination side<\/li> +
                            • SINGLE<\/strong> means the firewall has observed a single packet from that direction<\/li> +
                            • MULTIPLE<\/strong> means the firewall has observed multiple packets from that direction<\/li> + <\/ul> + <\/div>
                              -

                              Common Scenarios

                              -

                              This pattern typically occurs when a single request packet was sent, but the response came in multiple packets. This is very common with DNS queries where a small query packet is sent, but the response with DNS records is larger and may be split into multiple packets.

                              -
                              +

                              Common Scenarios<\/h4> +

                              This pattern typically occurs when a single request packet was sent, but the response came in multiple packets. This is very common with DNS queries where a small query packet is sent, but the response with DNS records is larger and may be split into multiple packets.<\/p> + <\/div>

                              -

                              Protocol Behavior

                              -

                              For UDP and other connectionless protocols, the firewall tracks state separately for each direction since UDP has no formal connection establishment like TCP does. This is completely normal for UDP connections.

                              -
                              -

                              • `; +

                              Protocol Behavior<\/h4> +

                              For UDP and other connectionless protocols, the firewall tracks state separately for each direction since UDP has no formal connection establishment like TCP does. This is completely normal for UDP connections.<\/p> + <\/div> + <\/div>`; } // If both parts are the same (e.g., "TIME_WAIT:TIME_WAIT", "ESTABLISHED:ESTABLISHED") @@ -4316,88 +4316,88 @@ 'ESTABLISHED': formatStateDescription( 'ESTABLISHED means a TCP connection is considered fully established by this side. According to pfSense documentation, this indicates the connection handshake (three-way handshake) has been completed and this side is actively exchanging data.', 'When you see ESTABLISHED:ESTABLISHED, it means both sides have a fully established two-way TCP connection. This is the normal, healthy state for active network sessions. Both directions are synchronized and actively communicating.', - '

                              Common examples include:

                              • Web browsing (HTTP/HTTPS)
                              • File transfers
                              • API communications
                              • Database connections
                              • SSH sessions
                              • Any active TCP service interaction
                              ' + '

                              Common examples include:<\/p>

                              • Web browsing (HTTP/HTTPS)<\/li>
                              • File transfers<\/li>
                              • API communications<\/li>
                              • Database connections<\/li>
                              • SSH sessions<\/li>
                              • Any active TCP service interaction<\/li><\/ul>' ), 'SYN_SENT': formatStateDescription( 'SYN_SENT means, for TCP connections, the side showing this state sent a TCP SYN packet attempting to start a connection handshake. According to pfSense documentation, this indicates the connection is being initiated.', 'This is a normal intermediate state that should quickly transition to ESTABLISHED or SYN_RECEIVED. If it persists, it indicates a connection attempt that failed or timed out.', - '

                                When you see SYN_SENT:CLOSED, it means the side showing SYN_SENT has sent a TCP SYN packet but no response has been received from the far side. This often occurs when:

                                • The packet was blocked by a firewall or security rule
                                • The packet was dropped or filtered along the network path
                                • The destination is not responding or unavailable
                                • Network routing issues prevent the packet from reaching its destination
                                • The destination service is not running or not listening on the target port
                                ' + '

                                When you see SYN_SENT:CLOSED, it means the side showing SYN_SENT has sent a TCP SYN packet but no response has been received from the far side. This often occurs when:<\/p>

                                • The packet was blocked by a firewall or security rule<\/li>
                                • The packet was dropped or filtered along the network path<\/li>
                                • The destination is not responding or unavailable<\/li>
                                • Network routing issues prevent the packet from reaching its destination<\/li>
                                • The destination service is not running or not listening on the target port<\/li><\/ul>' ), 'SYN_RECEIVED': formatStateDescription( 'SYN_RECEIVED means this side has received a TCP SYN packet from the remote endpoint and has sent a SYN-ACK response.', 'The connection is in the process of being established and is waiting for the final ACK packet to complete the three-way handshake.', - '

                                  This state typically appears:

                                  • On the receiving side when accepting inbound connection requests
                                  • During the second step of the three-way handshake
                                  • As a transitional state that should quickly move to ESTABLISHED

                                  The connection handshake is almost complete and should quickly transition to ESTABLISHED once the final acknowledgment is received from the initiating side.

                                  ' + '

                                  This state typically appears:<\/p>

                                  • On the receiving side when accepting inbound connection requests<\/li>
                                  • During the second step of the three-way handshake<\/li>
                                  • As a transitional state that should quickly move to ESTABLISHED<\/li><\/ul>

                                    The connection handshake is almost complete and should quickly transition to ESTABLISHED once the final acknowledgment is received from the initiating side.<\/p>' ), 'FIN_WAIT_1': formatStateDescription( 'FIN_WAIT_1 means a TCP connection is in the process of closing. According to pfSense documentation, TIME_WAIT/FIN_WAIT indicates a TCP connection is in the process of closing and finishing up.', 'FIN_WAIT_1 specifically means this side has sent a FIN (finish) packet to request closing the connection and is waiting for an acknowledgment (ACK) from the remote endpoint. This is the first step in the graceful connection termination process.', - '

                                    This state appears during normal connection shutdown sequences. The connection is being closed, but the remote side has not yet acknowledged the close request.

                                    ' + '

                                    This state appears during normal connection shutdown sequences. The connection is being closed, but the remote side has not yet acknowledged the close request.<\/p>' ), 'FIN_WAIT_2': formatStateDescription( 'FIN_WAIT_2 means a TCP connection is in the process of closing.', 'This side\'s FIN packet has been acknowledged by the remote endpoint, but the remote endpoint has not yet sent its own FIN packet to close the connection. The connection is partially closed from this side\'s perspective - it has signaled it wants to close and received acknowledgment, but is waiting for the remote side to also signal its intention to close.', - '

                                    This is a transitional state during connection termination where one side has initiated closure. The connection remains in this state until the remote endpoint sends its own FIN packet to complete the closure.

                                    ' + '

                                    This is a transitional state during connection termination where one side has initiated closure. The connection remains in this state until the remote endpoint sends its own FIN packet to complete the closure.<\/p>' ), 'TIME_WAIT': formatStateDescription( 'TIME_WAIT means a TCP connection is in the process of closing and finishing up.', 'The connection has been closed, but this side is keeping it in a waiting state for a period of time (typically 2-4 minutes) before fully releasing the connection resources.', - '

                                    This ensures that any delayed, out-of-order, or duplicate packets from the recently closed connection can be properly handled and discarded before a new connection potentially reuses the same port and sequence numbers.

                                    This is a normal part of TCP connection cleanup and helps prevent issues where old packets from a closed connection could interfere with new connections.

                                    ' + '

                                    This ensures that any delayed, out-of-order, or duplicate packets from the recently closed connection can be properly handled and discarded before a new connection potentially reuses the same port and sequence numbers.<\/p>

                                    This is a normal part of TCP connection cleanup and helps prevent issues where old packets from a closed connection could interfere with new connections.<\/p>' ), 'CLOSE_WAIT': formatStateDescription( 'CLOSE_WAIT means this side has received a FIN packet from the remote endpoint (meaning the remote side wants to close the connection), and this side is waiting for the local application to finish processing and send its own FIN packet to complete the closure.', 'This state appears when the remote endpoint initiates the connection closure.', - '

                                    The local application needs to:

                                    • Complete any pending operations
                                    • Clean up resources
                                    • Respond with its own close signal to complete the graceful shutdown
                                    ' + '

                                    The local application needs to:<\/p>

                                    • Complete any pending operations<\/li>
                                    • Clean up resources<\/li>
                                    • Respond with its own close signal to complete the graceful shutdown<\/li><\/ul>' ), 'CLOSING': formatStateDescription( 'CLOSING means both sides of the connection are simultaneously trying to close it.', 'Both this side and the remote endpoint have sent FIN packets and are waiting for acknowledgments from each other.', - '

                                      This is relatively uncommon but can occur when both sides decide to close the connection at nearly the same time. The connection is in the process of closing from both directions simultaneously, with both sides having signaled their intention to close.

                                      ' + '

                                      This is relatively uncommon but can occur when both sides decide to close the connection at nearly the same time. The connection is in the process of closing from both directions simultaneously, with both sides having signaled their intention to close.<\/p>' ), 'LAST_ACK': formatStateDescription( 'LAST_ACK means this side has sent a FIN packet and received an acknowledgment, but is waiting for the final acknowledgment (ACK) from the remote endpoint to complete the connection termination process.', 'This is the final stage of closing a connection.', - '

                                      Once this final ACK is received, the connection will transition to CLOSED and all resources will be fully released. This state indicates the connection is almost completely closed and just awaiting final confirmation.

                                      ' + '

                                      Once this final ACK is received, the connection will transition to CLOSED and all resources will be fully released. This state indicates the connection is almost completely closed and just awaiting final confirmation.<\/p>' ), 'LISTEN': formatStateDescription( 'LISTEN means this side is waiting for incoming connection requests on a specific port.', 'This state appears on servers that are ready to accept new connections from clients. The service is actively listening and waiting for clients to initiate connections.', - '

                                      Common examples include:

                                      • Web servers listening on port 80 (HTTP) or 443 (HTTPS)
                                      • SSH daemons on port 22
                                      • Database servers on their respective ports
                                      • Any service waiting to accept incoming connections

                                      This is normal for server applications that need to accept incoming connections.

                                      ' + '

                                      Common examples include:<\/p>

                                      • Web servers listening on port 80 (HTTP) or 443 (HTTPS)<\/li>
                                      • SSH daemons on port 22<\/li>
                                      • Database servers on their respective ports<\/li>
                                      • Any service waiting to accept incoming connections<\/li><\/ul>

                                        This is normal for server applications that need to accept incoming connections.<\/p>' ), 'CLOSED': formatStateDescription( 'CLOSED means, for TCP connections, the side with this status considers the connection closed, or the firewall has not received any traffic matching this state.', 'According to pfSense documentation, this indicates either the connection was never established, has been fully closed, or no packets have been observed.', - '

                                        All connection resources have been released, and the connection can no longer be used for data exchange. This is the final state after a connection has been completely closed, or the initial state before a connection is established.

                                        ' + '

                                        All connection resources have been released, and the connection can no longer be used for data exchange. This is the final state after a connection has been completely closed, or the initial state before a connection is established.<\/p>' ), 'NEW': formatStateDescription( 'NEW means a new connection has been detected but is not yet fully established.', 'This state appears during the very initial phase of connection setup, typically after the first packet is received but before the connection handshake is completed or recognized.', - '

                                        It\'s a transitional state that should quickly move to:

                                        • SYN_RECEIVED (for inbound connections)
                                        • ESTABLISHED (for fully established connections)

                                        Connections should not remain in NEW state for long periods. If they do, it may indicate an issue with connection establishment.

                                        ' + '

                                        It\'s a transitional state that should quickly move to:<\/p>

                                        • SYN_RECEIVED (for inbound connections)<\/li>
                                        • ESTABLISHED (for fully established connections)<\/li><\/ul>

                                          Connections should not remain in NEW state for long periods. If they do, it may indicate an issue with connection establishment.<\/p>' ), 'RELATED': formatStateDescription( 'RELATED means this connection is associated with an existing connection, often used by firewalls for state tracking and security purposes.', 'The firewall marks these connections as RELATED so they can be properly managed together, allowing the firewall to recognize that the connection is legitimate and related to an established primary connection.', - '

                                          This commonly appears with protocols like FTP that use multiple connections:

                                          • A control connection for commands
                                          • Separate data connections for file transfers

                                          This helps maintain security while allowing complex protocols that require multiple connections to function properly.

                                          ' + '

                                          This commonly appears with protocols like FTP that use multiple connections:<\/p>

                                          • A control connection for commands<\/li>
                                          • Separate data connections for file transfers<\/li><\/ul>

                                            This helps maintain security while allowing complex protocols that require multiple connections to function properly.<\/p>' ), 'INVALID': formatStateDescription( 'INVALID means the connection state does not conform to standard TCP/IP connection state machine rules, or it has been explicitly marked as invalid by the firewall due to policy violations or security concerns.', 'This indicates that the connection has violated protocol rules or security policies.', - '

                                            This may indicate:

                                            • Malformed or corrupted connection attempts that violate protocol rules
                                            • Connection attempts that don\'t follow proper state transitions
                                            • Connections flagged by security policies or intrusion detection systems
                                            • Potential security threats, port scans, or attack attempts
                                            • Protocol anomalies or implementation errors
                                            • Packets that don\'t match expected state machine transitions
                                            ', - 'Security Note: If you see many INVALID connections, especially from the same source, it may warrant security investigation as it could indicate malicious activity, port scanning, or misconfigured applications.' + '

                                            This may indicate:<\/p>

                                            • Malformed or corrupted connection attempts that violate protocol rules<\/li>
                                            • Connection attempts that don\'t follow proper state transitions<\/li>
                                            • Connections flagged by security policies or intrusion detection systems<\/li>
                                            • Potential security threats, port scans, or attack attempts<\/li>
                                            • Protocol anomalies or implementation errors<\/li>
                                            • Packets that don\'t match expected state machine transitions<\/li><\/ul>', + 'Security Note:<\/strong> If you see many INVALID connections, especially from the same source, it may warrant security investigation as it could indicate malicious activity, port scanning, or misconfigured applications.' ), 'NO_TRAFFIC': formatStateDescription( 'NO_TRAFFIC means the firewall has not received any packets that match this state from this direction. According to pfSense documentation, this indicates no packets have been observed from this side.', 'For UDP and other connectionless protocols, this means no response has been received from the destination side after an initial packet was sent.', - '

                                              This is common when you see SINGLE:NO_TRAFFIC, where one side sent a packet (SINGLE) but received no response (NO_TRAFFIC). According to pfSense, this is similar to SYN_SENT:CLOSED but for UDP and other connectionless protocols - no response has been received from the destination side.

                                              This could indicate:

                                              • The destination is not responding
                                              • Packets are being dropped by a firewall
                                              • The service is not available
                                              • Network connectivity issues
                                              ' + '

                                              This is common when you see SINGLE:NO_TRAFFIC, where one side sent a packet (SINGLE) but received no response (NO_TRAFFIC). According to pfSense, this is similar to SYN_SENT:CLOSED but for UDP and other connectionless protocols - no response has been received from the destination side.<\/p>

                                              This could indicate:<\/p>

                                              • The destination is not responding<\/li>
                                              • Packets are being dropped by a firewall<\/li>
                                              • The service is not available<\/li>
                                              • Network connectivity issues<\/li><\/ul>' ), 'SINGLE': formatStateDescription( 'SINGLE means the firewall has observed a single packet on this state from this side. According to pfSense documentation, this indicates only one packet has been seen from this direction.', 'For UDP and other connectionless protocols, this is common for UDP-based services where requests and responses may be asymmetric.', - '

                                                Common patterns:

                                                • SINGLE:NO_TRAFFIC - A request was sent but no response was received
                                                • SINGLE:MULTIPLE - According to pfSense documentation, this is commonly observed with DNS where the client sends one packet but receives a large response in multiple packets

                                                This pattern is normal for UDP connections, especially DNS queries where the query is small but the response with DNS records is larger.

                                                ' + '

                                                Common patterns:<\/p>

                                                • SINGLE:NO_TRAFFIC<\/strong> - A request was sent but no response was received<\/li>
                                                • SINGLE:MULTIPLE<\/strong> - According to pfSense documentation, this is commonly observed with DNS where the client sends one packet but receives a large response in multiple packets<\/li><\/ul>

                                                  This pattern is normal for UDP connections, especially DNS queries where the query is small but the response with DNS records is larger.<\/p>' ), 'MULTIPLE': formatStateDescription( 'MULTIPLE means the firewall has observed multiple packets on this state from this side. According to pfSense documentation, this indicates several packets have been seen from this direction.', 'For UDP and other connectionless protocols, this means multiple packets have been observed, indicating ongoing communication.', - '

                                                  When you see MULTIPLE:MULTIPLE, according to pfSense documentation, there are multiple packets in both directions, which is normal for a fully operational UDP connection.

                                                  This suggests active, ongoing bidirectional communication between both endpoints and indicates a healthy UDP-based service interaction.

                                                  ' + '

                                                  When you see MULTIPLE:MULTIPLE, according to pfSense documentation, there are multiple packets in both directions, which is normal for a fully operational UDP connection.<\/p>

                                                  This suggests active, ongoing bidirectional communication between both endpoints and indicates a healthy UDP-based service interaction.<\/p>' ), }; @@ -4405,15 +4405,15 @@ if (state.includes(':') && primaryState === secondaryState && stateDescriptions[stateUpper]) { const baseDescription = stateDescriptions[stateUpper]; const formatNote = `

                                                  -

                                                  State Format

                                                  -

                                                  The state "${state}" shows the same state for both directions (${primaryState}:${secondaryState}). The colon (:) separates:

                                                  +

                                                  State Format<\/h4> +

                                                  The state "${state}" shows the same state for both directions (${primaryState}:${secondaryState}). The colon (:) separates:<\/p>

                                                    -
                                                  • Left side (${primaryState}) = connection state for source-to-destination direction
                                                    • -
                                                  • Right side (${secondaryState}) = connection state for destination-to-source direction
                                                    • -
                                                  -

                                                  When both parts are identical, it indicates both directions are synchronized in the same state, which is typical for TCP connections.

                                                  -

                                                  `; - return baseDescription.replace('

', formatNote + '

'); +
  • Left side (${primaryState})<\/strong> = connection state for source-to-destination direction<\/li> +
  • Right side (${secondaryState})<\/strong> = connection state for destination-to-source direction<\/li> + <\/ul> +

    When both parts are identical, it indicates both directions are synchronized in the same state, which is typical for TCP connections.<\/p> + <\/div>`; + return baseDescription.replace('<\/div>', formatNote + '<\/div>'); } // Handle asymmetric states (e.g., SYN_SENT:CLOSED, SINGLE:NO_TRAFFIC) @@ -4423,7 +4423,7 @@ return formatStateDescription( 'SYN_SENT:CLOSED is a common pairing according to pfSense documentation.', 'The side showing SYN_SENT has sent a TCP SYN packet to initiate a connection, but no response has been received from the far side (hence CLOSED).', - '

    According to pfSense documentation, this often occurs when:

    • The packet was blocked by a firewall or security rule
    • The packet did not reach its destination
    • The destination is not responding or unavailable
    • Network routing issues prevent the packet from being delivered
    • The destination service is not running or not listening on the target port
    ', + '

    According to pfSense documentation, this often occurs when:<\/p>

    • The packet was blocked by a firewall or security rule<\/li>
    • The packet did not reach its destination<\/li>
    • The destination is not responding or unavailable<\/li>
    • Network routing issues prevent the packet from being delivered<\/li>
    • The destination service is not running or not listening on the target port<\/li><\/ul>', 'This is a normal state for connection attempts that fail or timeout. It indicates the connection attempt was initiated but never completed.' ); } @@ -4434,7 +4434,7 @@ return formatStateDescription( 'SINGLE:NO_TRAFFIC is a common pairing for UDP and other connectionless protocols according to pfSense documentation.', 'One side has sent a single packet (SINGLE), but no response has been received from the destination side (NO_TRAFFIC). According to pfSense documentation, this is similar to SYN_SENT:CLOSED but for UDP and other connectionless protocols.', - '

      This commonly occurs when:

      • A UDP request was sent but the destination did not respond
      • The response packet was dropped or filtered by a firewall
      • The destination service is not available or not responding
      • Network connectivity issues prevent the response from being received
      ', + '

      This commonly occurs when:<\/p>

      • A UDP request was sent but the destination did not respond<\/li>
      • The response packet was dropped or filtered by a firewall<\/li>
      • The destination service is not available or not responding<\/li>
      • Network connectivity issues prevent the response from being received<\/li><\/ul>', 'This is typical for UDP-based protocols like DNS when queries go unanswered.' ); } @@ -4452,14 +4452,14 @@ `According to pfSense documentation, each state entry contains two values with a colon between them, marking which value represents the state of the source (left) and which represents the destination (right). This asymmetric state pattern indicates that the connection is not synchronized between both directions.`, `
        -

        Source → Destination (${primaryState}):

        -

        ${primarySummary}

        -
        +

        Source → Destination (${primaryState}):<\/p> +

        ${primarySummary}<\/p> + <\/div>

        -

        Destination → Source (${secondaryState}):

        -

        ${secondarySummary}

        -
        -
        `, +

        Destination → Source (${secondaryState}):<\/p> +

        ${secondarySummary}<\/p> + <\/div> + <\/div>`, 'Each direction may be at a different stage of connection establishment, maintenance, or termination. This is common during connection setup, closure, or when one side is not responding.' ); } @@ -4473,7 +4473,7 @@ return formatStateDescription( `The "${primaryState || state}" state represents the current phase of the network connection lifecycle.`, 'This connection is in a state that indicates how it is being established, maintained, or terminated between your server and the remote endpoint.', - '

        The state format uses a colon (:) to separate the state for each direction when both directions are tracked.

        ' + '

        The state format uses a colon (:) to separate the state for each direction when both directions are tracked.<\/p>' ); }; @@ -6024,4 +6024,4 @@ window.lifecycleEventsExportData = @json($lifecycleEventsExportRows ?? []); - \ No newline at end of file +