* Remove global state
 * Allow per context configuration
 * Logging through SLF4J
 * Drop pre-java 1.7 support
 * Unify authentication subsystem, NTLMSSP/Kerberos support
 * Large ReadX/WriteX support
 * Streaming list operations
 * NtTransNotifyChange support
 * Google patches: various bugfixes, lastAccess support, retrying requests
 * A proper test suite
 * Various fixes

## Others

### This jcifs or jcifs-ng

 *      file operations.
 * </ul>
 *
 * <p>The jCIFS API maps all of these operations into the standard Java
 * <code>XxxputStream</code> interface. A special <code>PIPE_TYPE</code>
 * flags is necessary to distinguish which type of Named Pipe behavior
 * is desired.
 *
 * <p><table border="1" cellpadding="3" cellspacing="0" width="100%">
 * <tr bgcolor="#ccccff">

     */

    public static final int PIPE_TYPE_RDWR = SmbConstants.O_RDWR;

    /**
     * Pipe operations should behave like the <code>CallNamedPipe</code> Win32 Named Pipe function.
     */

    public static final int PIPE_TYPE_CALL = 0x0100;

    /**
     * Pipe operations should behave like the <code>TransactNamedPipe</code> Win32 Named Pipe function.
     */

            throw new SmbException(u.toString() + " directory must end with '/'");

        if ( locator.getType() != SmbConstants.TYPE_SERVER )
            throw new SmbException("The requested list operations is invalid: " + u.toString());

        Set<FileEntry> set = new HashSet<>();

        if ( tc.getDfs().isTrustedDomain(tc, locator.getServer()) ) {
            /*

    @Override
    public CommonServerMessageBlockRequest split () {
        ServerMessageBlock2Request<?> n = getNext();
        if ( n != null ) {
            setNext(null);
            n.clearFlags(SMB2_FLAGS_RELATED_OPERATIONS);
        }
        return n;
    }


    /**
     * 
     * @param next
     */
    public void setNext ( ServerMessageBlock2Request<?> next ) {
        super.setNext(next);
    }

            this.response = new NetServerEnum2Response(th.getConfig());
        }
        else {
            throw new SmbException("The requested list operations is invalid: " + locator.getURL());
        }

        this.treeHandle = th.acquire();
        try {
            this.next = open();
        }
        catch ( Exception e ) {

        buffer[i] = b;
        if (i == BLOCK_LENGTH - 1)
            transform(buffer, 0);
    }

    /**
     * MD4 block update operation.
     * <p>
     * Continues an MD4 message digest operation, by filling the buffer,
     * transform(ing) data in 512-bit message block(s), updating the variables
     * context and count, and leaving (buffering) the remaining bytes in buffer

     * {@inheritDoc}
     *
     * @see jcifs.internal.RequestWithPath#setResolveInDfs(boolean)
     */
    @Override
    public void setResolveInDfs ( boolean resolve ) {
        addFlags(SMB2_FLAGS_DFS_OPERATIONS);
        this.resolveDfs = resolve;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.RequestWithPath#isResolveInDfs()
     */
    @Override

 * return 0 for streams connected to regular files. However, a 
 * stream created from a Named Pipe this method will query the server using a
 * "peek named pipe" operation and return the number of available bytes
 * on the server.
 */
    public int available() throws IOException {
        SmbNamedPipe pipe;
        TransPeekNamedPipe req;
        TransPeekNamedPipeResponse resp;

     * "peek named pipe" operation and return the number of available bytes
     * on the server.
     */
    @Override
    public int available () throws IOException {
        return 0;
    }


    /**
     * Skip n bytes of data on this stream. This operation will not result
     * in any IO with the server. Unlink <tt>InputStream</tt> value less than