import jcifs.smb1.dcerpc.ndr.*;

public class DcerpcBind extends DcerpcMessage {

    static final String[] result_message = {
        "0",
        "DCERPC_BIND_ERR_ABSTRACT_SYNTAX_NOT_SUPPORTED",
        "DCERPC_BIND_ERR_PROPOSED_TRANSFER_SYNTAXES_NOT_SUPPORTED",
        "DCERPC_BIND_ERR_LOCAL_LIMIT_EXCEEDED"
    };

    static String getResultMessage(int result) {
        return result < 4 ?
                result_message[result] :

    }


    /**
     * Bind the handle
     * 
     * @throws DcerpcException
     * @throws IOException
     */
    public void bind () throws DcerpcException, IOException {
        synchronized ( this ) {
            try {
                this.state = 1;
                DcerpcMessage bind = new DcerpcBind(this.binding, this);
                sendrecv(bind);
            }

                                    new TransWaitNamedPipeResponse() );
        }
        writeDirect( b, off, len, 0 );
    }
/**
 * Just bypasses TransWaitNamedPipe - used by DCERPC bind.
 */
    public void writeDirect( byte[] b, int off, int len, int flags ) throws IOException {
        if( len <= 0 ) {
            return;
        }

        if( tmp == null ) {

    @Override
    public void write ( byte[] b, int off, int len ) throws IOException {
        writeDirect(b, off, len, 0);
    }


    /**
     * Just bypasses TransWaitNamedPipe - used by DCERPC bind.
     * 
     * @param b
     * @param off
     * @param len
     * @param flags
     * @throws IOException
     */
    public void writeDirect ( byte[] b, int off, int len, int flags ) throws IOException {

    }
    a.sort {
        display: block;
        float: left;
        width: 100px;
        height: 15px;
        font-family: Verdana, sans-serif;
        font-size: 8pt;
        font-weight: bold;
        text-decoration: none;
        color: #000000;
        background-color: #d0d0d0;
        border-top-color: #ffffff;
        border-bottom-color: #707070;
        border-right-color: #707070;

     */
    @Override
    public void releaseBuffer ( byte[] buf ) {
        if ( buf == null ) {
            return;
        }
        // better safe than sorry: prevent leaks if there is some out of bound access
        Arrays.fill(buf, (byte) 0);
        synchronized ( this.cache ) {
            if ( this.freeBuffers < this.cache.length ) {
                for ( int i = 0; i < this.cache.length; i++ ) {

            buf.dec_ndr_short();        /* cancel count */
        }
        if (ptype == 3 || ptype == 13) {               /* Fault */
            result = buf.dec_ndr_long();
        } else {                        /* Bind_ack or Response */
            decode_out(buf);
        }
    }

    public abstract int getOpnum();
    public abstract void encode_in(NdrBuffer buf) throws NdrException;

            buf.dec_ndr_short(); /* cancel count */
        }
        if ( this.ptype == 3 || this.ptype == 13 ) { /* Fault */
            this.result = buf.dec_ndr_long();
        }
        else { /* Bind_ack or Response */
            decode_out(buf);
        }
    }


    /**
     * 
     * @return the operation number
     */
    public abstract int getOpnum ();


    /**

/**
 * 
 * @author mbechler
 *
 */
public class DcerpcBind extends DcerpcMessage {

    private static final String[] result_message = {
        "0", "DCERPC_BIND_ERR_ABSTRACT_SYNTAX_NOT_SUPPORTED", "DCERPC_BIND_ERR_PROPOSED_TRANSFER_SYNTAXES_NOT_SUPPORTED",
        "DCERPC_BIND_ERR_LOCAL_LIMIT_EXCEEDED"
    };


    private static String getResultMessage ( int result ) {

        }
        throw new DcerpcException("DCERPC transport not supported: " + url);
    }

    public void bind() throws DcerpcException, IOException {
synchronized (this) {
        try {
            state = 1;
            DcerpcMessage bind = new DcerpcBind(binding, this);
            sendrecv(bind);
        } catch (IOException ioe) {
            state = 0;
            throw ioe;
        }
}
    }