/**
   * Writes all the bytes from the given {@code InputStream} to this sink. Does not close {@code
   * input}.
   *
   * @return the number of bytes written
   * @throws IOException if an I/O occurs while reading from {@code input} or writing to this sink
   */
  @CanIgnoreReturnValue
  public long writeFrom(InputStream input) throws IOException {
    checkNotNull(input);

    try (OutputStream out = openStream()) {

        SMB1SigningDigest.writeUTime(mockConfig, testTime, dst, 0);

        int expectedSeconds = (int) (testTime / 1000L);
        int actualSeconds = SMBUtil.readInt4(dst, 0);
        assertEquals(expectedSeconds, actualSeconds);

        // Test when current time is in DST but test time is not
        when(mockTimeZone.inDaylightTime(any(Date.class))).thenReturn(true) // current time

    public AvFlags(final int flags) {
        this(encode(flags));
    }

    /**
     * Gets the flags as an integer value
     * @return flags
     */
    public int getFlags() {
        return SMBUtil.readInt4(this.getRaw(), 0);
    }

    private static byte[] encode(final int flags) {
        final byte[] raw = new byte[4];
        SMBUtil.writeInt4(flags, raw, 0);
        return raw;
    }

     */
    @Override
    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 24) {
            throw new SMBProtocolDecodingException("Expected structureSize = 24");
        }

        this.oplockLevel = buffer[bufferIndex + 2];

        assertEquals(expectedTimestamp, avTimestamp.getTimestamp());
    }

    /**
     * Test getTimestamp method with a negative timestamp (though timestamps are usually positive).
     * This tests the underlying SMBUtil.readInt8 behavior.
     */
    @Test
    public void testGetTimestampNegative() {
        long expectedTimestamp = -1L; // Represents all bits set to 1 for an 8-byte long
        byte[] rawBytes = new byte[8];

        return 0;
    }

    @Override
    int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        length = readInt4(buffer, bufferIndex);
        return 4;
    }

    @Override
    int readDataWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;

        if (errorCode != 0) {

    private byte[] tmp = new byte[1];

    SmbFile file;

    private boolean largeReadX;

    private final boolean unsharedFile;

    private boolean smb2;

    /**
     * Creates an input stream for reading from the specified SMB URL
     *
     * @param url the SMB URL to read from
     * @param tc
     *            context to use
     * @throws SmbException if an SMB error occurs

                channel = new RandomAccessFile(touchfile, "rw").getChannel();
                lock = channel.lock();

                if (touchfile.canRead()) {
                    getLogger().debug("Reading resolution-state from: " + touchfile);
                    props.load(Channels.newInputStream(channel));
                }

                props.setProperty(key, Long.toString(System.currentTimeMillis()));

		os.Mkdir(extractDir, 0o755)
		w, err := os.Create(dst)
		if err != nil {
			return fmt.Errorf("creating output file: %w", err)
		}
		_, err = io.Copy(w, stream)
		if err != nil {
			return fmt.Errorf("reading inspect stream: %w", err)
		}
		fmt.Printf("Extracted: %s\n", dst)
		extracted = true
	}

The **Advanced User Guide** builds on this one, uses the same concepts, and teaches you some extra features.

But you should first read the **Tutorial - User Guide** (what you are reading right now).