fbuf.reset();
        fbuf.setIndex(8);
        fbuf.setLength(fbuf.dec_ndr_short());

        if ( this.securityProvider != null ) {
            this.securityProvider.unwrap(fbuf);
        }
    }


    /**
     * @param msg
     * @param out
     * @return
     * @throws NdrException
     * @throws DcerpcException
     */

                DfsReferralData initial = null;
                @SuppressWarnings ( "resource" )
                SmbTransportInternal trans = dc != null ? dc.unwrap(SmbTransportInternal.class) : null;
                if ( trans != null ) {
                    // get domain referral

 * 
 * @author mbechler
 *
 */
public interface SmbTree extends AutoCloseable {

    /**
     * 
     * @param type
     * @return tree instance with the given type
     */
    <T extends SmbTree> T unwrap ( Class<T> type );


    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close ();

 * @author mbechler
 *
 */
public interface Credentials {

    /**
     * 
     * @param type
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Credentials> T unwrap ( Class<T> type );


    /**
     * @return the domain the user account is in
     */
    String getUserDomain ();


    /**
     * @return whether these are anonymous credentials
     */

        this.uncPath = this.pipe.getUncPath();
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbPipeHandle#unwrap(java.lang.Class)
     */
    @SuppressWarnings ( "unchecked" )
    @Override
    public <T extends SmbPipeHandle> T unwrap ( Class<T> type ) {
        if ( type.isAssignableFrom(this.getClass()) ) {
            return (T) this;
        }
        throw new ClassCastException();

            }
        }
    }


    /**
     * 
     * {@inheritDoc}
     *
     * @see jcifs.SID#unwrap(java.lang.Class)
     */
    @SuppressWarnings ( "unchecked" )
    @Override
    public <T> T unwrap ( Class<T> t ) {
        if ( t.isAssignableFrom(this.getClass()) ) {
            return (T) this;
        }
        throw new ClassCastException();
    }

                    th.send(treq, RequestParam.NO_RETRY);
                }
            }
        }
        catch ( CIFSException e ) {
            throw SmbException.wrap(e);
        }
    }


    SmbFileOutputStream ( SmbFile file, SmbTreeHandleImpl th, SmbFileHandleImpl handle, int openFlags, int access, int sharing )
            throws CIFSException {
        this.file = file;

 */

package jcifs.smb1.dcerpc;

import jcifs.smb1.dcerpc.ndr.NdrBuffer;

public interface DcerpcSecurityProvider
{
    void wrap(NdrBuffer outgoing) throws DcerpcException;
    void unwrap(NdrBuffer incoming) throws DcerpcException;

     * @return whether the FD was previously open but became invalid
     */
    boolean isStale ();


    /**
     * @param type
     * @return unwrapped instance
     */
    <T extends SmbPipeHandle> T unwrap ( Class<T> type );

    public CIFSContext withCredentials ( Credentials creds ) {
        return wrap(this.delegate.withCredentials(creds));
    }


    @Override
    public CIFSContext withDefaultCredentials () {
        return wrap(this.delegate.withDefaultCredentials());
    }


    @Override
    public CIFSContext withAnonymousCredentials () {
        return wrap(this.delegate.withAnonymousCredentials());
    }