static int qcrypto_ivgen_essiv_calculate(QCryptoIVGen *ivgen,

                                         uint64_t sector,

                                         uint8_t *iv, size_t niv,

                                         Error **errp)

{

    QCryptoIVGenESSIV *essiv = ivgen->private;

    size_t ndata = qcrypto_cipher_get_block_len(ivgen->cipher);

    uint8_t *data = g_new(uint8_t, ndata);



    sector = cpu_to_le64(sector);

    memcpy(data, (uint8_t *)&sector, ndata);

    if (sizeof(sector) < ndata) {

        memset(data + sizeof(sector), 0, ndata - sizeof(sector));

    }



    if (qcrypto_cipher_encrypt(essiv->cipher,

                               data,

                               data,

                               ndata,

                               errp) < 0) {

        g_free(data);

        return -1;

    }



    if (ndata > niv) {

        ndata = niv;

    }

    memcpy(iv, data, ndata);

    if (ndata < niv) {

        memset(iv + ndata, 0, niv - ndata);

    }

    g_free(data);

    return 0;

}

static int qcrypto_ivgen_essiv_calculate(QCryptoIVGen *ivgen,

                                         uint64_t sector,

                                         uint8_t *iv, size_t niv,

                                         Error **errp)

{

    QCryptoIVGenESSIV *essiv = ivgen->private;

    size_t ndata = qcrypto_cipher_get_block_len(ivgen->cipher);

    uint8_t *data = g_new(uint8_t, ndata);



    sector = cpu_to_le64(sector);

    memcpy(data, (uint8_t *)&sector, ndata);

    if (sizeof(sector) < ndata) {

        memset(data + sizeof(sector), 0, ndata - sizeof(sector));

    }



    if (qcrypto_cipher_encrypt(essiv->cipher,

                               data,

                               data,

                               ndata,

                               errp) < 0) {

        g_free(data);

        return -1;

    }



    if (ndata > niv) {

        ndata = niv;

    }

    memcpy(iv, data, ndata);

    if (ndata < niv) {

        memset(iv + ndata, 0, niv - ndata);

    }

    g_free(data);

    return 0;

}

    memcpy(data, (uint8_t *)&sector, ndata);
static int FUNC_0(QCryptoIVGen *VAR_0,

                                         uint64_t VAR_1,

                                         uint8_t *VAR_2, size_t VAR_3,

                                         Error **VAR_4)

{

    QCryptoIVGenESSIV *essiv = VAR_0->private;

    size_t ndata = qcrypto_cipher_get_block_len(VAR_0->cipher);

    uint8_t *data = g_new(uint8_t, ndata);



    VAR_1 = cpu_to_le64(VAR_1);

    memcpy(data, (uint8_t *)&VAR_1, ndata);

    if (sizeof(VAR_1) < ndata) {

        memset(data + sizeof(VAR_1), 0, ndata - sizeof(VAR_1));

    }



    if (qcrypto_cipher_encrypt(essiv->cipher,

                               data,

                               data,

                               ndata,

                               VAR_4) < 0) {

        g_free(data);

        return -1;

    }



    if (ndata > VAR_3) {

        ndata = VAR_3;

    }

    memcpy(VAR_2, data, ndata);

    if (ndata < VAR_3) {

        memset(VAR_2 + ndata, 0, VAR_3 - ndata);

    }

    g_free(data);

    return 0;

}

static int FUNC_0(QCryptoIVGen *VAR_0,
uint64_t VAR_1,
uint8_t *VAR_2, size_t VAR_3,
Error **VAR_4)
{ QCryptoIVGenESSIV *essiv = VAR_0->private; size_t ndata = qcrypto_cipher_get_block_len(VAR_0->cipher); uint8_t *data = g_new(uint8_t, ndata); VAR_1 = cpu_to_le64(VAR_1); memcpy(data, (uint8_t *)&VAR_1, ndata); if (sizeof(VAR_1) < ndata) { memset(data + sizeof(VAR_1), 0, ndata - sizeof(VAR_1)); } if (qcrypto_cipher_encrypt(essiv->cipher,
data,
data,
ndata,
VAR_4) < 0) { g_free(data); return -1; } if (ndata > VAR_3) { ndata = VAR_3; } memcpy(VAR_2, data, ndata); if (ndata < VAR_3) { memset(VAR_2 + ndata, 0, VAR_3 - ndata); } g_free(data); return 0; }