There may be many routes for a single address. For example, a webserver that is hosted in multiple datacenters may yield multiple IP addresses in its DNS response.

   OkHttp.
 * Expose the transport ("http/1.1", "spdy/3", etc.) via magic request headers.
   Use `X-Android-Transports` to write the preferred transports and
   `X-Android-Selected-Transport` to read the negotiated transport.


## Version 1.0.2

_2013-05-11_

 * Fix: Remove use of Java 6-only APIs.
 * Fix: Properly handle exceptions from `NetworkInterface` when querying MTU.

    /**
     * Function code to trim file level storage
     */
    public static final int FSCTL_FILE_LEVEL_TRIM = 0x00098208;
    /**
     * Function code to validate SMB2 negotiate information
     */
    public static final int FSCTL_VALIDATE_NEGOTIATE_INFO = 0x000140204;

    /**
     * Flag indicating this IOCTL is a file system control operation
     */

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("DiSNI RDMA write failed", e);
        }
    }

    @Override
    public RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException {
        // Simulate successful negotiation for skeleton implementation
        RdmaNegotiateResponse response = new RdmaNegotiateResponse();

/**
 * This servlet may be used to "browse" the entire hierarchy of resources
 * on an SMB network like one might with Network Neighborhood or Windows
 * Explorer. The users credentials with be negotiated using NTLM SSP if
 * the client is Microsoft Internet Explorer.
 *
 * @deprecated Unsupported
 */
@Deprecated
/**
 * A servlet that provides network browsing capabilities for SMB shares.

        boolean dfsStrictView = delegatingConfig.isDfsStrictView();

        // Then
        assertTrue(smb2Only, "Should delegate SMB2 only negotiation");
        assertFalse(secureNegotiate, "Should delegate secure negotiate requirement");
        assertTrue(ntlmTargetName, "Should delegate NTLM target name setting");
        assertFalse(port139Failover, "Should delegate port 139 failover setting");

        assertFalse(negotiationResponse.isSigningRequired());
        assertTrue(negotiationResponse.isSigningNegotiated());

        // Signing required (implies enabled and negotiated)
        when(negotiationResponse.isSigningEnabled()).thenReturn(true);
        when(negotiationResponse.isSigningRequired()).thenReturn(true);
        when(negotiationResponse.isSigningNegotiated()).thenReturn(true);

            log.debug("No support or SMB signing is enabled, not enabling large writes");
            this.writeSizeFile = this.writeSize;
        }

        if (log.isDebugEnabled()) {
            log.debug("Negotiated file write size is " + this.writeSizeFile);
        }

        if (this.useNTSmbs) {
            this.reqx = new SmbComWriteAndX(th.getConfig());
            this.rspx = new SmbComWriteAndXResponse(th.getConfig());

                dc_list_expiration = 0;
            } while (retry-- > 0);

            dc_list_expiration = now + 1000 * 60 * 15; /* 15 min */
        }

        throw new UnknownHostException("Failed to negotiate with a suitable domain controller for " + DOMAIN);
    }

    /**
     * Retrieves the NTLM challenge from the specified domain controller.
     *
     * @param dc the domain controller address

        } else {
            log.debug("LARGE_READX disabled");
            this.readSizeFile = this.readSize;
        }

        if (log.isDebugEnabled()) {
            log.debug("Negotiated file read size is " + this.readSizeFile);
        }
    }

    /**
     * Ensures that the file descriptor is openend
     *
     * @throws CIFSException if an error occurs while opening the file
     */