/** The low-level TCP socket. */
  private val rawSocket: JavaNetSocket,
  /**
   * The application layer socket. Either an [SSLSocket] layered over [rawSocket], or [rawSocket]
   * itself if this connection does not use SSL.
   */
  private val javaNetSocket: JavaNetSocket,
  private val handshake: Handshake?,
  private val protocol: Protocol,
  private val socket: BufferedSocket,
  private val pingIntervalMillis: Int,

     */
    public static final int OVERHEAD = Smb2Constants.SMB2_HEADER_LENGTH + 48;

    private byte[] data;
    private int dataOffset;
    private int dataLength;

    private byte[] fileId;
    private long offset;
    private int channel;
    private int remainingBytes;
    private int writeFlags;
    private RdmaChannelInfo rdmaChannelInfo;

    /**

		os.Exit(1)
	}

	// dump private key to file
	privateKeyBytes := x509.MarshalPKCS1PrivateKey(privatekey)
	privateKeyBlock := &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: privateKeyBytes,
	}
	privatePem, err := os.Create("support_private.pem")
	if err != nil {
		fmt.Printf("error when create private.pem: %s n", err)
		os.Exit(1)
	}

    /**
     * Total number of records.
     */
    private int allRecordCount;

    /**
     * Total number of pages.
     */
    private int allPageCount;

    /**
     * Flag indicating whether a previous page exists.
     */
    private boolean existPrePage;

    /**
     * Flag indicating whether a next page exists.
     */
    private boolean existNextPage;

    /**

 */
internal class FastFallbackExchangeFinder(
  override val routePlanner: RoutePlanner,
  private val taskRunner: TaskRunner,
) : ExchangeFinder {
  private val connectDelayNanos = TimeUnit.MILLISECONDS.toNanos(250L)
  private var nextTcpConnectAtNanos = Long.MIN_VALUE

  /**
   * Plans currently being connected, and that will later be added to [connectResults]. This is

internal class DerReader(
  source: Source,
) {
  private val countingSource: CountingSource = CountingSource(source)
  private val source: BufferedSource = countingSource.buffer()

  /** Total bytes read thus far. */
  private val byteCount: Long
    get() = countingSource.bytesRead - source.buffer.size

  /** How many bytes to read before [peekHeader] should return false, or -1L for no limit. */
  private var limit = -1L

  @SuppressWarnings("unchecked")
  protected B self() {
    return (B) this;
  }

  // Test Data

  private @Nullable G subjectGenerator;
  // Gets run before every test.
  private Runnable setUp;
  // Gets run at the conclusion of every test.
  private Runnable tearDown;

  @CanIgnoreReturnValue
  protected B usingGenerator(G subjectGenerator) {
    this.subjectGenerator = subjectGenerator;

import okhttp3.ResponseBody
import okhttp3.internal.stripBody
import okhttp3.sse.EventSource
import okhttp3.sse.EventSourceListener

internal class RealEventSource private constructor(
  private val call: Call?,
  private val request: Request,
  private val listener: EventSourceListener,
) : EventSource,
  ServerSentEventReader.Callback,
  Callback {

    private boolean existPrePage;

    /** Flag indicating whether a next page exists. */
    private boolean existNextPage;

    /** List of page numbers for pagination navigation. */
    private List<Integer> pageNumberList;

    /** Number of records to display per page. */
    private int pageSize;

    /** Current page number being displayed. */
    private int currentPageNumber;

 */

public class NbtSocket extends Socket {

    private static final int SSN_SRVC_PORT = 139;
    private static final int BUFFER_SIZE = 512;
    private static final int DEFAULT_SO_TIMEOUT = 5000;

    private static LogStream log = LogStream.getInstance();

    private NbtAddress address;
    private Name calledName;
    private int soTimeout;

    /**
     * Constructs an unconnected NbtSocket.