<mime-type type="audio/l8"/>
  <mime-type type="audio/lpc"/>

  <mime-type type="audio/midi">
    <acronym>MIDI</acronym>
    <_comment>Musical Instrument Digital Interface</_comment>
    <magic priority ="20">
      <match type="string" value="MThd" offset="0"/>
    </magic>
    <glob pattern="*.mid"/>
    <glob pattern="*.midi"/>
    <glob pattern="*.kar"/>
    <glob pattern="*.rmi"/>
  </mime-type>

    abstract int readBytesWireFormat( byte[] buffer, int bufferIndex );

    public int hashCode() {
        return mid;
    }
    public boolean equals( Object obj ) {
        return obj instanceof ServerMessageBlock && ((ServerMessageBlock)obj).mid == mid;
    }
    public String toString() {
        String c;
        switch( command ) {
            case SMB_COM_NEGOTIATE:

                socket.setSoTimeout( SO_TIMEOUT );

                out = socket.getOutputStream();
                in = socket.getInputStream();
            }

            if (++mid == 32000) mid = 1;
            NEGOTIATE_REQUEST.mid = mid;
            int n = NEGOTIATE_REQUEST.encode( sbuf, 4 );
            Encdec.enc_uint32be( n & 0xFFFF, sbuf, 0 ); /* 4 byte ssn msg header */

            if (log.level >= 4) {

 * @author mbechler
 *
 */
public class SmbComNtCancel extends ServerMessageBlock {

    /**
     * @param config
     */
    protected SmbComNtCancel ( Configuration config, int mid ) {
        super(config, SMB_COM_NT_CANCEL);
        setMid(mid);
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#isCancel()
     */
    @Override
    public boolean isCancel () {

    /**
     * @return status code
     */
    int getErrorCode ();


    /**
     * @param k
     */
    void setMid ( long k );


    /**
     * @return mid
     */
    long getMid ();


    /**
     * 
     * @param buffer
     * @param i
     * @param size
     * @return whether signature verification is successful
     */

        this.localTimeZone = TimeZone.getDefault();
        this.random = new SecureRandom();

        if ( this.machineId == null ) {
            byte[] mid = new byte[32];
            this.random.nextBytes(mid);
            this.machineId = mid;
        }

        if ( this.nativeOs == null ) {
            this.nativeOs = System.getProperty("os.name");
        }

        if ( this.flags2 == 0 ) {

            andx.errorCode = errorCode;
            andx.flags = flags;
            andx.flags2 = flags2;
            andx.tid = tid;
            andx.pid = pid;
            andx.uid = uid;
            andx.mid = mid;
            andx.useUnicode = useUnicode;

            if( andx instanceof AndXServerMessageBlock ) {
                bufferIndex += ((AndXServerMessageBlock)andx).readAndXWireFormat(

        Smb2SigningDigest dgst = getDigest();
        if ( dgst != null && !isAsync() && ( getConfig().isRequireSecureNegotiate() || getErrorCode() == NtStatus.NT_STATUS_OK ) ) {
            // TODO: SMB2 - do we need to check the MIDs?
            // We only read what we were waiting for, so first guess would be no.
            boolean verify = dgst.verify(buffer, i, size, 0, this);
            this.verifyFailed = verify;
            return !verify;

	case debugIsOutgoingClosed:
		// params: muxID uint64, isClosed func(bool)
		muxID := args[0].(uint64)
		resp := args[1].(func(b bool))
		mid, ok := c.outgoing.Load(muxID)
		if !ok || mid == nil {
			resp(true)
			return
		}
		mid.respMu.Lock()
		resp(mid.closed)
		mid.respMu.Unlock()
	case debugBlockInboundMessages:
		c.connMu.Lock()
		block := (<-chan struct{})(args[0].(chan struct{}))

          swap(array, from, to);
        }
        return array[k];
      } else {
        int midIndex = (from + to) >>> 1;
        // Choose the median of the elements at the from, to and mid indexes,
        // and rearrange so that array[from]<=array[from+1], and
        // array[to] => array[from + 1].

        swap(array, midIndex, from + 1);

        if (array[from] > array[to]) {