}
        }
    }

    /*
     * Prepare reflective access to ExtendedGSSContext. The reflective access
     * abstracts the access so far, that Oracle JDK, Open JDK and IBM JDK are
     * supported.
     * 
     * At the time of the first implementation only a test on Oracle JDK was
     * done.
     */

        String fname = config.getFileName().toString();
        if ( !fname.endsWith(".conf") ) {
            return;
        }
        Properties props = new Properties();
        try ( FileChannel ch = FileChannel.open(config, StandardOpenOption.READ);
              InputStream is = Channels.newInputStream(ch) ) {
            props.load(is);

        }
        if ( !props.isEmpty() ) {

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

    @Override
    protected int doSendReceiveFragment ( byte[] buf, int off, int length, byte[] inB ) throws IOException {
        if ( this.handle.isStale() ) {
            throw new IOException("DCERPC pipe is no longer open");
        }

        int have = this.handle.sendrecv(buf, off, length, inB, getMaxRecv());

        int fraglen = Encdec.dec_uint16le(inB, 8);
        if ( fraglen > getMaxRecv() ) {

        this.wildcard = wildcard;
        this.nameFilter = filter;
        this.searchAttributes = searchAttributes;

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

    }

    /**
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen () throws CIFSException {
        // ensure file is open
        if ( this.handle == null || !this.handle.isValid() ) {
            // one extra acquire to keep this open till the stream is released
            this.handle = this.file.openUnshared(this.openFlags, this.access, this.sharing, SmbConstants.ATTR_NORMAL, this.options).acquire();

     * @param append
     *            whether to append to or truncate the input
     * @param openFlags
     *            flags for open operation
     * @param access
     *            desired file access flags
     * @param sharing
     *            flags indicating for which operations others may open the file
     * @return output stream, needs to be closed when finished
     * @throws CIFSException
     */

                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);

                }
                else if ( ( flags & SmbConstants.O_CREAT ) == O_CREAT ) {
                    req.setCreateDisposition(Smb2CreateRequest.FILE_OPEN_IF);
                }
                else {
                    req.setCreateDisposition(Smb2CreateRequest.FILE_OPEN);
                }

                req.setShareAccess(sharing);
                req.setFileAttributes(attrs);

                break;
            case SMB_COM_NT_CREATE_ANDX:
                c = "SMB_COM_NT_CREATE_ANDX";
                break;
            case SMB_COM_OPEN_ANDX:
                c = "SMB_COM_OPEN_ANDX";
                break;
            case SMB_COM_READ_ANDX:
                c = "SMB_COM_READ_ANDX";
                break;
            case SMB_COM_CLOSE: