/**
 * @author mbechler
 *
 */
public interface CommonServerMessageBlock extends Message {

    /**
     * Decode message data from the given byte array
     * 
     * @param buffer
     * @param bufferIndex
     * @return message length
     * @throws SMBProtocolDecodingException
     */
    int decode ( byte[] buffer, int bufferIndex ) throws SMBProtocolDecodingException;


    /**
     * @param dst

	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBatchJobReplicateCredentials Msgsize() is inaccurate")
	}

	vn := BatchJobReplicateCredentials{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

    }

    /* Decode floating point numbers
     */

    public static float dec_floatle( byte[] src, int si )
    {
        return Float.intBitsToFloat( dec_uint32le( src, si ));
    }
    public static float dec_floatbe( byte[] src, int si )
    {
        return Float.intBitsToFloat( dec_uint32be( src, si ));
    }

    /* Encode and decode doubles
     */

    }


    /*
     * Decode floating point numbers
     */

    public static float dec_floatle ( byte[] src, int si ) {
        return Float.intBitsToFloat(dec_uint32le(src, si));
    }


    public static float dec_floatbe ( byte[] src, int si ) {
        return Float.intBitsToFloat(dec_uint32be(src, si));
    }


    /*
     * Encode and decode doubles
     */

    } catch (e: NoSuchElementException) {
      throw IllegalArgumentException("failed to decode certificate", e)
    } catch (e: IllegalArgumentException) {
      throw IllegalArgumentException("failed to decode certificate", e)
    } catch (e: GeneralSecurityException) {
      throw IllegalArgumentException("failed to decode certificate", e)
    }
  }
}

internal data class TbsCertificate(

    public long getFree () {
        return this.free * this.sectPerAlloc * this.bytesPerSect;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {
        int start = bufferIndex;
        this.alloc = SMBUtil.readInt8(buffer, bufferIndex);

	"log"
)

func bytesToPrivateKey(priv []byte) (*rsa.PrivateKey, error) {
	// Try PEM
	if block, _ := pem.Decode(priv); block != nil {
		return x509.ParsePKCS1PrivateKey(block.Bytes)
	}
	// Try base 64
	dst := make([]byte, base64.StdEncoding.DecodedLen(len(priv)))
	if n, err := base64.StdEncoding.Decode(dst, priv); err == nil {
		return x509.ParsePKCS1PrivateKey(dst[:n])
	}
	// Try Raw, return error

    public long getFree () {
        return this.free * this.sectPerAlloc * this.bytesPerSect;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {
        int start = bufferIndex;

        // Read total allocation units.

     * @return the totalBytesWritten
     */
    public byte[] getData () {
        return this.data;
    }


    /**
     * {@inheritDoc}
     *
     * @see Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) throws SMBProtocolDecodingException {
        int start = bufferIndex;
        this.namedPipeState = SMBUtil.readInt4(buffer, bufferIndex);

        return this.tflags;
    }


    /**
     * @return the referrals
     */
    public final Referral[] getReferrals () {
        return this.referrals;
    }


    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) {
        int start = bufferIndex;

        this.pathConsumed = SMBUtil.readInt2(buffer, bufferIndex) / 2;
        bufferIndex += 2;