void
ENGINE_register_all_ECDH(void)
{
ENGINE *e;
for (e = ENGINE_get_first(); e; e = ENGINE_get_next(e))
ENGINE_register_ECDH(e);
}
static void resume_engine(void *ctx,int mem)
{
ENGINE *e=(ENGINE *)ctx;
if(mem&0x01)ENGINE_register_RSA(e);
if(mem&0x02)ENGINE_register_DSA(e);
#if OPENSSL_VERSION_NUMBER >= 0x1010000fL
if(mem&0x04)ENGINE_register_EC(e);
#else
if(mem&0x04)ENGINE_register_ECDH(e);
if(mem&0x08)ENGINE_register_ECDSA(e);
#endif
if(mem&0x10)ENGINE_register_DH(e);
if(mem&0x20)ENGINE_register_RAND(e);
}
int ENGINE_register_complete(ENGINE *e)
{
ENGINE_register_ciphers(e);
ENGINE_register_digests(e);
#ifndef OPENSSL_NO_RSA
ENGINE_register_RSA(e);
#endif
#ifndef OPENSSL_NO_DSA
ENGINE_register_DSA(e);
#endif
#ifndef OPENSSL_NO_DH
ENGINE_register_DH(e);
#endif
#ifndef OPENSSL_NO_EC
ENGINE_register_ECDH(e);
ENGINE_register_ECDSA(e);
#endif
ENGINE_register_RAND(e);
ENGINE_register_pkey_meths(e);
return 1;
}
static int openssl_engine_register(lua_State*L)
{
ENGINE* eng = CHECK_OBJECT(1, ENGINE, "openssl.engine");
int unregister = 0;
int first = 2;
int top = lua_gettop(L);
if (lua_isboolean(L, 2))
{
unregister = lua_toboolean(L, 2);
first = 3;
};
while (first <= top)
{
int c = luaL_checkoption(L, first, "RSA", list);
switch (c)
{
case TYPE_RSA:
if (unregister)
ENGINE_unregister_RSA(eng);
else
ENGINE_register_RSA(eng);
break;
case TYPE_DSA:
if (unregister)
ENGINE_unregister_DSA(eng);
else
ENGINE_register_DSA(eng);
break;
case TYPE_ECDH:
if (unregister)
ENGINE_unregister_ECDH(eng);
else
ENGINE_register_ECDH(eng);
break;
case TYPE_ECDSA:
if (unregister)
ENGINE_unregister_ECDSA(eng);
else
ENGINE_register_ECDSA(eng);
break;
case TYPE_DH:
if (unregister)
ENGINE_unregister_DH(eng);
else
ENGINE_register_DH(eng);
break;
case TYPE_RAND:
if (unregister)
ENGINE_unregister_RAND(eng);
else
ENGINE_register_RAND(eng);
break;
case TYPE_STORE:
if (unregister)
ENGINE_unregister_STORE(eng);
else
ENGINE_register_STORE(eng);
break;
case TYPE_CIPHERS:
if (unregister)
ENGINE_unregister_ciphers(eng);
else
ENGINE_register_ciphers(eng);
break;
case TYPE_DIGESTS:
if (unregister)
ENGINE_unregister_digests(eng);
else
ENGINE_register_digests(eng);
break;
case TYPE_COMPLETE:
{
int ret = ENGINE_register_complete(eng);
lua_pushboolean(L, ret);
return 1;
break;
}
default:
luaL_error(L, "not support %d for %s", c, list[c]);
break;
}
first++;
}
return 0;
};
ERL_NIF_TERM engine_register_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{/* (Engine, EngineMethod) */
#ifdef HAS_ENGINE_SUPPORT
struct engine_ctx *ctx;
unsigned int method;
// Get Engine
ASSERT(argc == 2);
if (!enif_get_resource(env, argv[0], engine_ctx_rtype, (void**)&ctx))
goto bad_arg;
if (!enif_get_uint(env, argv[1], &method))
goto bad_arg;
switch(method)
{
#ifdef ENGINE_METHOD_RSA
case ENGINE_METHOD_RSA:
if (!ENGINE_register_RSA(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_DSA
case ENGINE_METHOD_DSA:
if (!ENGINE_register_DSA(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_DH
case ENGINE_METHOD_DH:
if (!ENGINE_register_DH(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_RAND
case ENGINE_METHOD_RAND:
if (!ENGINE_register_RAND(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_ECDH
case ENGINE_METHOD_ECDH:
if (!ENGINE_register_ECDH(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_ECDSA
case ENGINE_METHOD_ECDSA:
if (!ENGINE_register_ECDSA(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_STORE
case ENGINE_METHOD_STORE:
if (!ENGINE_register_STORE(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_CIPHERS
case ENGINE_METHOD_CIPHERS:
if (!ENGINE_register_ciphers(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_DIGESTS
case ENGINE_METHOD_DIGESTS:
if (!ENGINE_register_digests(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_PKEY_METHS
case ENGINE_METHOD_PKEY_METHS:
if (!ENGINE_register_pkey_meths(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_PKEY_ASN1_METHS
case ENGINE_METHOD_PKEY_ASN1_METHS:
if (!ENGINE_register_pkey_asn1_meths(ctx->engine))
goto failed;
break;
#endif
#ifdef ENGINE_METHOD_EC
case ENGINE_METHOD_EC:
if (!ENGINE_register_EC(ctx->engine))
goto failed;
break;
#endif
default:
return ERROR_Atom(env, "engine_method_not_supported");
}
return atom_ok;
bad_arg:
return enif_make_badarg(env);
failed:
return ERROR_Atom(env, "register_engine_failed");
#else
return atom_notsup;
#endif
}
