* @see jcifs.SmbPipeHandle#isStale()
     */
    @Override
    public boolean isStale () {
        return !this.open || ( this.handle != null && !this.handle.isValid() );
    }


    @Override
    public synchronized SmbFileHandleImpl ensureOpen () throws CIFSException {
        if ( !this.open ) {
            throw new SmbException("Pipe handle already closed");
        }

        if ( !isOpen() ) {

    static final int FLAGS_COPY_SOURCE_MODE_ASCII = 0x0008;
    static final int FLAGS_VERIFY_ALL_WRITES = 0x0010;
    static final int FLAGS_TREE_COPY = 0x0020;

    // open function
    static final int OPEN_FUNCTION_FAIL_IF_EXISTS = 0x0000;
    static final int OPEN_FUNCTION_OVERWRITE_IF_EXISTS = 0x0020;

    static final int SECURITY_SHARE = 0x00;
    static final int SECURITY_USER = 0x01;

    static final int CMD_OFFSET = 4;

                    // fail if already exists
                    this.openFunction = OPEN_FN_CREATE | OPEN_FN_FAIL_IF_EXISTS;
                }
                else {
                    this.openFunction = OPEN_FN_CREATE | OPEN_FN_OPEN;
                }
            }
            else {
                this.openFunction = OPEN_FN_OPEN;
            }
        }
    }


    @Override

have exclusive access to the file. An additional open command
from jCIFS or another application will fail with the "file is being
accessed by another process" error. The <code>FILE_SHARE_READ</code>,
<code>FILE_SHARE_WRITE</code>, and <code>FILE_SHARE_DELETE</code> may be
combined with the bitwise OR '|' to specify that other peocesses may read,
write, and/or delete the file while the jCIFS user has the file open.
 * 

    }


    /**
     * @return whether the stream is open
     */
    public boolean isOpen () {
        return this.handle != null && this.handle.isValid();
    }


    protected synchronized SmbFileHandleImpl ensureOpen () throws CIFSException {
        if ( !isOpen() ) {
            // one extra acquire to keep this open till the stream is released

 * </pre>
 * 
 * </td>
 * <td>
 * Open the Named Pipe foo for reading and writing. The pipe will behave like the <code>CallNamedPipe</code> interface.
 * </td>
 * </tr>
 * <tr>
 * <td width="20%">
 * 
 * <pre>
 * new SmbNamedPipe("smb://server/IPC$/foo", SmbNamedPipe.PIPE_TYPE_RDWR | SmbNamedPipe.PIPE_TYPE_TRANSACT, context);
 * </pre>
 * 
 * </td>
 * <td>

    public int read( byte b[], int off, int len ) throws SmbException {
        if( len <= 0 ) {
            return 0;
        }
        long start = fp;

        // ensure file is open
        if( file.isOpen() == false ) {
            file.open( openFlags, 0, SmbFile.ATTR_NORMAL, options );
        }

        int r, n;
        SmbComReadAndXResponse response = new SmbComReadAndXResponse( b, off );
        do {

 *         SmbNamedPipe.PIPE_TYPE_CALL );
 * </pre></td><td>
 * Open the Named Pipe foo for reading and writing. The pipe will behave like the <code>CallNamedPipe</code> interface.
 * </td></tr>
 * <tr><td width="20%"><pre>
 * new SmbNamedPipe( "smb1://server/IPC$/foo",
 *         SmbNamedPipe.PIPE_TYPE_RDWR |
 *         SmbNamedPipe.PIPE_TYPE_TRANSACT );
 * </pre></td><td>

    String path;

    /* batchLimits indecies
     *
     * 0 = SMB_COM_CHECK_DIRECTORY
     * 2 = SMB_COM_CREATE_DIRECTORY
     * 3 = SMB_COM_DELETE
     * 4 = SMB_COM_DELETE_DIRECTORY
     * 5 = SMB_COM_OPEN_ANDX
     * 6 = SMB_COM_RENAME
     * 7 = SMB_COM_TRANSACTION
     * 8 = SMB_COM_QUERY_INFORMATION
     */

    /* All batch limits are single batch only until further notice
     */

                if ( trans.isSMB2() ) {
                    Smb2CreateRequest create = new Smb2CreateRequest(sess.getConfig(), "\\foocc");
                    create.setCreateDisposition(Smb2CreateRequest.FILE_OPEN_IF);
                    create.setRequestedOplockLevel(Smb2CreateRequest.SMB2_OPLOCK_LEVEL_BATCH);



                    try {
                        tree.send(create);