if (offerBasic) {
                    response.addHeader("WWW-Authenticate", "Basic realm=\"" + realm + "\"");
                }
                response.setHeader("Connection", "close");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.flushBuffer();
                return;
            }

                // ERR_SSN_SRVC
                Arguments.of(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED, "ERR_SSN_SRVC/Connection refused"),
                Arguments.of(NbtException.ERR_SSN_SRVC, NbtException.NOT_LISTENING_CALLED, "ERR_SSN_SRVC/Not listening on called name"),

    private FileEntry next;
    private int ridx;

    private boolean closed = false;

    /**
     * Creates a directory entry enumeration iterator.
     *
     * @param th the SMB tree handle for the connection
     * @param parent the parent resource being enumerated
     * @param wildcard the wildcard pattern for filtering entries
     * @param filter additional resource name filter to apply

     * to the <code>OutputStream</code> associated with this Named
     * Pipe instance although this is not a requirement (e.g. a
     * read-only named pipe would write data to this stream on
     * connection). Reading from this stream may block. Therefore it
     * may be necessary that an addition thread be used to read and
     * write to a Named Pipe.
     * @return the input stream for reading from this pipe

    private int currentPageNumber;

    /** The unique identifier for the file authentication entry. */
    public String id;

    /** The port number for the file authentication connection. */
    public String port;

    /** The username for file authentication. */
    public String username;

    /** The file configuration ID associated with this authentication. */
    public String fileConfigId;

     *   <li>OPTIONS - Returns the HTTP methods that the server supports.</li>
     *   <li>TRACE - Echoes back the received request, used for debugging.</li>
     *   <li>CONNECT - Converts the request connection to a transparent TCP/IP tunnel.</li>
     * </ul>
     */
    public enum Method {
        /**
         * HTTP GET method.
         */
        GET,
        /**
         * HTTP POST method.

        ChannelInfo channel = new ChannelInfo("failover-test", mockTransport, nic, nic);
        channel.setState(ChannelState.ESTABLISHED);

        // Simulate failure
        IOException failure = new IOException("Connection lost");
        failover.handleFailure(channel, failure);

        // Verify channel state changed
        assertFalse(channel.isHealthy());
        assertEquals(ChannelState.FAILED, channel.getState());
    }

- Thread-local storage via `CrawlingParameterUtil`

**Resource Management**:
- `AutoCloseable` throughout
- `DeferredFileOutputStream` for large responses (temp files for >1MB)
- Connection pooling with limits
- Background temp file deletion via `FileUtil.deleteInBackground()`

**Fault Tolerance**:
- `FaultTolerantClient` wrapper (retry, circuit breaker)

     */

    @Override
    public String toString() {
        return Strings.maskSecretValue(url.toString());
    }

    /* URLConnection implementation */
    /**
     * This URLConnection method just returns the result of {@code length()}.
     *
     * @return the length of this file or 0 if it refers to a directory
     */

    @Override

        String channelId = "channel-" + channelCounter.incrementAndGet();
        ChannelInfo channel = new ChannelInfo(channelId, transport, localIf, remoteIf);

        // Establish connection
        channel.setState(ChannelState.CONNECTING);
        // Connection would be ensured through proper transport interface

        // Perform channel binding
        performChannelBinding(channel);

        // Add to active channels