@Override
    public synchronized void write(final byte[] b, int off, final int len) throws IOException {
        if (len > 0xFFFF) {
            throw new IOException("write too large: " + len);
        }
        if (off < 4) {
            throw new IOException("NetBIOS socket output buffer requires 4 bytes available before off");
        }

        off -= 4;

        b[off + 0] = (byte) SessionServicePacket.SESSION_MESSAGE;

            result = len > used ? used : len;
            if (used > i && result > i) {
                System.arraycopy(pipe_buf, beg_idx, b, off, i);
                off += i;
                System.arraycopy(pipe_buf, 0, b, off, result - i);
            } else {
                System.arraycopy(pipe_buf, beg_idx, b, off, result);
            }
            used -= result;
            beg_idx = (beg_idx + result) % pipe_buf.length;
        }

		// don't spend all our time copying.
		copy(b.buf, b.buf[b.off:])
	} else if c > maxInt-c-n {
		panic(ErrTooLarge)
	} else {
		// Add b.off to account for b.buf[:b.off] being sliced off the front.
		b.buf = growSlice(b.buf[b.off:], b.off+n)
	}
	// Restore b.off and len(b.buf).
	b.off = 0
	b.buf = b.buf[:m+n]
	return m
}

    byte[] b;
    int off, dataCompactionMode, dataLength, dataOffset;

    SmbComReadAndXResponse() {
    }

    SmbComReadAndXResponse(final byte[] b, final int off) {
        this.b = b;
        this.off = off;
    }

    void setParam(final byte[] b, final int off) {
        this.b = b;
        this.off = off;
    }

    @Override

                if (off + stub_frag_len > stub.length) {
                    // shouldn't happen if alloc_hint is correct or greater
                    final byte[] tmp = new byte[off + stub_frag_len];
                    System.arraycopy(stub, 0, tmp, 0, off);
                    stub = tmp;
                }

                System.arraycopy(frag, 24, stub, off, stub_frag_len);

        assertEquals(expected, len);

        int off = 0;
        assertEquals(65535, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(65535, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(0, SMBUtil.readInt2(buf, off));
        off += 2;
        assertEquals(0x12345678, SMBUtil.readInt4(buf, off));
        off += 4;
        assertEquals(blob.length, SMBUtil.readInt2(buf, off));

        }

        while (off < length) {
            final int r = this.handle.recv(buf, off, length - off);
            if (r == 0) {
                throw new IOException("Unexpected EOF");
            }
            off += r;
        }
        return off;
    }

    @Override
    public void close() throws IOException {
        super.close();
        try {
            this.handle.close();

                    len -= cnt;
                    off += cnt;
                } else {
                    if (log.isTraceEnabled()) {
                        log.trace(String.format("Wrote at %d remain %d off %d len %d", this.fp, len - w, off, w));
                    }
                    this.req.setParam(fh.getFid(), this.fp, len - w, b, off, w);
                    th.send(this.req, this.rsp);

        this.b = b;
        this.off = off;
    }

    /**
     * Sets the parameters for this write request.
     *
     * @param fid the file identifier
     * @param offset the file offset at which to write
     * @param remaining the number of bytes remaining to be written
     * @param b the data buffer containing bytes to write
     * @param off the offset in the buffer where data starts

        this.b = b;
        this.off = off;
        dataLength = len;
        command = SMB_COM_WRITE_ANDX;
    }

    void setParam(final int fid, final long offset, final int remaining, final byte[] b, final int off, final int len) {
        this.fid = fid;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;
        this.off = off;
        dataLength = len;