URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {
                    @Override
                    public URLStreamHandler createURLStreamHandler(String protocol) {
                        if ("smb".equals(protocol)) {
                            return new Handler();
                        }
                        return null;
                    }
                });

 */
package jcifs;

/**
 * Interface for objects that can be encoded to a byte buffer.
 * This interface provides methods for serializing data to SMB protocol messages.
 *
 * @author mbechler
 */
public interface Encodable {

    /**
     * Encodes this object into the specified byte array.
     *
     * @param dst the destination byte array to encode into

 */
package jcifs;

import jcifs.internal.SMBProtocolDecodingException;

/**
 * Interface for objects that can be decoded from a byte buffer.
 * This interface provides methods for deserializing data from SMB protocol messages.
 *
 * @author mbechler
 */
public interface Decodable {

    /**
     * Decode data from a byte buffer
     *
     * @param buffer the byte buffer containing the data to decode

     * Operation range error fault code
     */
    int DCERPC_FAULT_OP_RNG_ERROR = 0x1C010002;
    /**
     * Unknown interface fault code
     */
    int DCERPC_FAULT_UNK_IF = 0x1C010003;
    /**
     * Protocol error fault code
     */
    int DCERPC_FAULT_PROTO_ERROR = 0x1c01000b;

    /**
     * Array of all DCE/RPC fault codes
     */
    int[] DCERPC_FAULT_CODES =

     *
     * @param id an id
     * @return corresponding authentication info
     */
    AuthenticationInfo getAuthenticationInfo(String id);

    ProxyInfo getProxy(String protocol);

    void getArtifact(Artifact artifact, ArtifactRepository repository)
            throws TransferFailedException, ResourceDoesNotExistException;

        // IPv6 without port
        assertEquals("https://[::1]", IpAddressUtil.buildUrl("https", ipv6, 0, ""));

        // Null protocol or address
        assertNull(IpAddressUtil.buildUrl(null, ipv4, 8080, "/path"));
        assertNull(IpAddressUtil.buildUrl("http", (InetAddress) null, 8080, "/path"));
    }

    @Test

        }
        throw new DcerpcException("DCERPC transport not supported: " + url);
    }

    /**
     * Bind the handle
     *
     * @throws DcerpcException
     *            if there is a DCE/RPC protocol error
     * @throws IOException
     *            if there is an I/O error during binding
     */
    public void bind() throws DcerpcException, IOException {
        synchronized (this) {
            try {

import jcifs.internal.smb1.trans.SmbComTransactionResponse;
import jcifs.internal.util.SMBUtil;

/**
 * Base class for SMB1 NT Transaction response messages.
 *
 * NT Transactions are an extended form of the basic transaction protocol
 * that provides additional functionality for Windows NT-specific operations.
 */
public abstract class SmbComNtTransactionResponse extends SmbComTransactionResponse {

 */

package jcifs.smb1.smb1;

import java.io.Serializable;

import jcifs.smb1.UniAddress;
import jcifs.smb1.util.Hexdump;

/**
 * Represents an NTLM authentication challenge in SMB1 protocol.
 */
public final class NtlmChallenge implements Serializable {

    /**
     * The NTLM challenge bytes received from the server.
     */
    public byte[] challenge;
    /**

    val request =
      Request
        .Builder()
        .url("https://localhost:1/")
        .build()
    val interceptorResponse =
      Response
        .Builder()
        .request(request)
        .protocol(Protocol.HTTP_1_1)
        .code(200)
        .message("Intercepted!")
        .body("abc".toResponseBody("text/plain; charset=utf-8".toMediaType()))
        .build()
    client =
      client
        .newBuilder()