*/
public class SmbTransport extends Transport implements SmbConstants {

    static final byte[] BUF = new byte[0xFFFF];
    static final SmbComNegotiate NEGOTIATE_REQUEST = new SmbComNegotiate();
    static LogStream log = LogStream.getInstance();
    static HashMap dfsRoots = null;

    static synchronized SmbTransport getSmbTransport(final UniAddress address, final int port) {

     */
    public SmbTransport getDc(final String domain, final NtlmPasswordAuthentication auth) throws SmbAuthException {
        if (DISABLED) {
            return null;
        }

        try {
            UniAddress addr = UniAddress.getByName(domain, true);
            final SmbTransport trans = SmbTransport.getSmbTransport(addr, 0);

        void testMultipleTransportTypes() throws Exception {
            // Given
            SmbTransport sharedTransport = mock(SmbTransport.class);
            SmbTransport exclusiveTransport = mock(SmbTransport.class);
            SmbTransport signedTransport = mock(SmbTransport.class);

            when(transportPool.getSmbTransport(context, address, DEFAULT_PORT, false)).thenReturn(sharedTransport);

    void unwrapBehavior() {
        // Happy paths
        SmbTransport asIface = transport.unwrap(SmbTransport.class);
        assertSame(transport, asIface);
        SmbTransportInternal asInternal = transport.unwrap(SmbTransportInternal.class);
        assertSame(transport, asInternal);

        // Invalid type should throw
        class OtherTransport implements SmbTransport {
            @Override

        final UniAddress dc = new UniAddress(addr);
        final SmbTransport trans = SmbTransport.getSmbTransport(dc, 0);
        if (USERNAME == null) {
            trans.connect();
            if (LogStream.level >= 3) {
                SmbTransport.log.println("""
                        Default credentials (jcifs.smb1.smb1.client.username/password)\

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicLong;

import jcifs.SmbTransport;
import jcifs.internal.CommonServerMessageBlock;

/**
 * Information about a multi-channel connection
 */
public class ChannelInfo {

    private final String channelId;
    private volatile SmbTransport transport;
    private final NetworkInterfaceInfo localInterface;

        }
    }

    private void attemptRecoveryWithTransport(ChannelInfo channel, FailoverState state, SmbTransport newTransport) {
        try {
            log.info("Attempting to recover channel {}", channel.getChannelId());

            // Disconnect existing transport
            SmbTransport oldTransport = channel.getTransport();
            if (oldTransport != null) {
                try {

     * @return whether (non-exclusive) connection is in the pool
     */
    public boolean contains(final SmbTransport trans) {
        cleanup();
        return this.connections.contains(trans);
    }

    @Override
    public void removeTransport(final SmbTransport trans) {
        if (log.isDebugEnabled()) {

    }
}
```

### 4.2 Channel Information
```java
package jcifs.internal.smb2.multichannel;

import jcifs.smb.SmbTransport;
import java.util.concurrent.atomic.AtomicLong;

public class ChannelInfo {
    private final String channelId;
    private final SmbTransport transport;
    private final NetworkInterfaceInfo localInterface;
    private final NetworkInterfaceInfo remoteInterface;

     * @return created transport
     * @throws IOException if transport creation fails
     */
    public SmbTransport createTransport(NetworkInterfaceInfo localInterface, NetworkInterfaceInfo remoteInterface) throws IOException {
        // This would need to be implemented based on the actual SmbTransport constructor
        // For now, return null - this needs integration with the actual transport creation