* single "stop" control is required to interrupt or turn off ancillary devices, DC4 is the
   * preferred assignment.)
   *
   * @since 8.0
   */
  public static final byte DC3 = 19; // aka XOFF

  /**
   * Transmission off. See {@link #XON} for explanation.
   *
   * @since 8.0
   */
  public static final byte XOFF = 19; // aka DC3

  /**

    }

    public synchronized void write( byte[] b, int off, int len ) throws IOException {
        if( len > 0xFFFF ) {
            throw new IOException( "write too large: " + len );
        } else 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;

		// 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
}

        super(config, SMB_COM_WRITE);
        this.fid = fid;
        this.count = len;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;
        this.off = off;
    }


    /**
     * 
     * @param fid
     * @param offset
     * @param remaining
     * @param b
     * @param off
     * @param len
     */

            System.arraycopy( b, off, pipe_buf, nxt_idx, i );
            off += i;
            System.arraycopy( b, off, pipe_buf, 0, len - i ); 
        } else {
            System.arraycopy( b, off, pipe_buf, nxt_idx, len );
        }
        nxt_idx = ( nxt_idx + len ) % pipe_buf.length;
        used += len;
        return len;
    }
    public int dce_read( byte[] b, int off, int len ) throws IOException {

                if ((off + stub_frag_len) > stub.length) {
                    // shouldn't happen if alloc_hint is correct or greater
                    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);
                off += stub_frag_len;

                    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;
        dataLength = len;
        command = SMB_COM_WRITE_ANDX;
    }

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

)

// Test BoolFlag.String()
func TestBoolFlagString(t *testing.T) {
	var bf BoolFlag

	testCases := []struct {
		flag           BoolFlag
		expectedResult string
	}{
		{bf, "off"},
		{BoolFlag(true), "on"},
		{BoolFlag(false), "off"},
	}

	for _, testCase := range testCases {
		str := testCase.flag.String()
		if testCase.expectedResult != str {
			t.Fatalf("expected: %v, got: %v", testCase.expectedResult, str)
		}

class SmbComReadAndXResponse extends AndXServerMessageBlock {

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

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

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