class OpenSSL::CMS

static VALUE
ossl_cms_initialize(int argc, VALUE *argv, VALUE self)
{
    CMS_ContentInfo *cms, *out = DATA_PTR(self);
    BIO *in;
    VALUE arg;

    if(rb_scan_args(argc, argv, "01", &arg) == 0)
        return self;

    arg = ossl_to_der_if_possible(arg);
    in = ossl_obj2bio(arg);

    cms = PEM_read_bio_CMS(in, &out, NULL, NULL);
    if (!cms) {
        OSSL_BIO_reset(in);
        cms = d2i_CMS_bio(in, &out);

        if (!cms) {
            BIO_free(in);
            CMS_ContentInfo_free(out);
            DATA_PTR(self) = NULL;
            ossl_raise(rb_eArgError, "Could not parse the CMS");
        }
    }

    DATA_PTR(self) = out;
    BIO_free(in);
    ossl_cms_set_data(self, Qnil);
    ossl_cms_set_err_string(self, Qnil);

    return self;
}

static VALUE
ossl_cms_s_read_cms(VALUE klass, VALUE arg)
{
    BIO *in;
    CMS_ContentInfo *cms, *out;
    VALUE ret;

    arg = ossl_to_der_if_possible(arg);
    in = ossl_obj2bio(arg);
    out = CMS_ContentInfo_new();
    cms = PEM_read_bio_CMS(in, &out, NULL, NULL);

    if (!cms) {
        OSSL_BIO_reset(in);
        cms = d2i_CMS_bio(in, &out);

        if (!cms) {
            BIO_free(in);
            CMS_ContentInfo_free(out);
            ossl_raise(rb_eArgError, "Could not parse the CMS");
        }
    }

    WrapCMS(cCMS, ret, cms);
    BIO_free(in);
    ossl_cms_set_data(ret, Qnil);
    ossl_cms_set_err_string(ret, Qnil);

    return ret;
}

static VALUE
ossl_cms_to_der(VALUE self)
{
    CMS_ContentInfo *cms;
    VALUE str;
    long len;
    unsigned char *p;

    GetCMS(self, cms);
    if((len = i2d_CMS_ContentInfo(cms, NULL)) <= 0)
        ossl_raise(eCMSError, NULL);

    str = rb_str_new(0, len);
    p = (unsigned char *)RSTRING_PTR(str);

    if(i2d_CMS_ContentInfo(cms, &p) <= 0)
        ossl_raise(eCMSError, NULL);

    ossl_str_adjust(str, p);

    return str;
}

static VALUE
ossl_cms_to_pem(VALUE self)
{
    CMS_ContentInfo *cms;
    VALUE str;
    BIO *out;

    GetCMS(self, cms);
    if (!(out = BIO_new(BIO_s_mem()))) {
        ossl_raise(eCMSError, NULL);
    }
    if (!PEM_write_bio_CMS(out, cms)) {
        BIO_free(out);
        ossl_raise(eCMSError, NULL);
    }

    str = ossl_membio2str(out);

    return str;
}

static VALUE
ossl_cms_verify(int argc, VALUE *argv, VALUE self)
{
    VALUE certs, store, indata, flags;
    STACK_OF(X509) *x509s;
    X509_STORE *x509st;
    int flg, ok, status = 0;
    BIO *in, *out;
    CMS_ContentInfo *cms;
    VALUE data;
    const char *msg;

    rb_scan_args(argc, argv, "22", &certs, &store, &indata, &flags);
    flg = NIL_P(flags) ? 0 : NUM2INT(flags);

    if(NIL_P(indata)) indata = ossl_cms_get_data(self);
    in = NIL_P(indata) ? NULL : ossl_obj2bio(indata);

    if(NIL_P(certs)) x509s = NULL;
    else{
        x509s = ossl_protect_x509_ary2sk(certs, &status);
        if(status){
            BIO_free(in);
            rb_jump_tag(status);
        }
    }

    x509st = GetX509StorePtr(store);
    GetCMS(self, cms);

    if(!(out = BIO_new(BIO_s_mem()))){
        BIO_free(in);
        sk_X509_pop_free(x509s, X509_free);
        ossl_raise(eCMSError, NULL);
    }

    ok = CMS_verify(cms, x509s, x509st, in, out, flg);

    BIO_free(in);
    if (ok < 0) ossl_raise(eCMSError, NULL);

    msg = ERR_reason_error_string(ERR_get_error());
    ossl_cms_set_err_string(self, msg ? rb_str_new2(msg) : Qnil);
    ERR_clear_error();

    data = ossl_membio2str(out);

    ossl_cms_set_data(self, data);
    sk_X509_pop_free(x509s, X509_free);

    return (ok == 1) ? Qtrue : Qfalse;
}