/* crypto/engine/hw_cluster_labs.c */ /* Written by Jan Tschirschwitz (jan.tschirschwitz@cluster-labs.com * for the OpenSSL project 2000. */ /* ==================================================================== * Copyright (c) 1999 The OpenSSL Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. All advertising materials mentioning features or use of this * software must display the following acknowledgment: * "This product includes software developed by the OpenSSL Project * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" * * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to * endorse or promote products derived from this software without * prior written permission. For written permission, please contact * licensing@OpenSSL.org. * * 5. Products derived from this software may not be called "OpenSSL" * nor may "OpenSSL" appear in their names without prior written * permission of the OpenSSL Project. * * 6. Redistributions of any form whatsoever must retain the following * acknowledgment: * "This product includes software developed by the OpenSSL Project * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" * * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. * ==================================================================== * * This product includes cryptographic software written by Eric Young * (eay@cryptsoft.com). This product includes software written by Tim * Hudson (tjh@cryptsoft.com). * */ #define MSC_VER /* only used cryptic.h */ #include #include #include #include #include #ifndef NO_HW #ifndef NO_HW_CLUSTER_LABS #ifdef FLAT_INC #include "cluster_labs.h" #else #include "vendor_defns/cluster_labs.h" #endif #define CL_LIB_NAME "cluster_labs engine" #include "hw_cluster_labs_err.c" static int cluster_labs_destroy(ENGINE *e); static int cluster_labs_init(ENGINE *e); static int cluster_labs_finish(ENGINE *e); static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()); /* BIGNUM stuff */ /* This function is aliased to mod_exp (with the mont stuff dropped). */ static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); /* RSA stuff */ #ifndef OPENSSL_NO_RSA static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding); static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding); static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding); static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding); static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa); #endif /* DSA stuff */ #ifndef OPENSSL_NO_DSA static DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, DSA *dsa); static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len, DSA_SIG *sig, DSA *dsa); static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont); static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); #endif /* DH stuff */ #ifndef OPENSSL_NO_DH /* This function is alised to mod_exp (with the DH and mont dropped). */ static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); #endif /* RANDOM stuff */ static int cluster_labs_rand_bytes(unsigned char *buf, int num); /* The definitions for control commands specific to this engine */ #define CLUSTER_LABS_CMD_SO_PATH ENGINE_CMD_BASE static const ENGINE_CMD_DEFN cluster_labs_cmd_defns[] = { { CLUSTER_LABS_CMD_SO_PATH, "SO_PATH", "Specifies the path to the 'cluster labs' shared library", ENGINE_CMD_FLAG_STRING }, {0, NULL, NULL, 0} }; /* Our internal RSA_METHOD that we provide pointers to */ #ifndef OPENSSL_NO_RSA static RSA_METHOD cluster_labs_rsa = { "Cluster Labs RSA method", cluster_labs_rsa_pub_enc, /* rsa_pub_enc */ cluster_labs_rsa_pub_dec, /* rsa_pub_dec */ cluster_labs_rsa_priv_enc, /* rsa_priv_enc */ cluster_labs_rsa_priv_dec, /* rsa_priv_dec */ cluster_labs_rsa_mod_exp, /* rsa_mod_exp */ cluster_labs_mod_exp_mont, /* bn_mod_exp */ NULL, /* init */ NULL, /* finish */ 0, /* flags */ NULL, /* apps_data */ NULL, /* rsa_sign */ NULL /* rsa_verify */ }; #endif /* Our internal DSA_METHOD that we provide pointers to */ #ifndef OPENSSL_NO_DSA static DSA_METHOD cluster_labs_dsa = { "Cluster Labs DSA method", cluster_labs_dsa_sign, /* dsa_do_sign */ NULL, /* dsa_sign_setup */ cluster_labs_dsa_verify, /* dsa_do_verify */ cluster_labs_dsa_mod_exp, /* dsa_mod_exp */ cluster_labs_mod_exp_dsa, /* bn_mod_exp */ NULL, /* init */ NULL, /* finish */ 0, /* flags */ NULL /* app_data */ }; #endif /* Our internal DH_METHOD that we provide pointers to */ #ifndef OPENSSL_NO_DH static DH_METHOD cluster_labs_dh = { "Cluster Labs DH method", NULL, /* generate key */ NULL, /* compute key */ cluster_labs_mod_exp_dh, /* bn_mod_exp */ NULL, /* init */ NULL, /* finish */ 0, /* flags */ NULL /* app_data */ }; #endif static RAND_METHOD cluster_labs_rand = { /* "Cluster Labs RAND method", */ NULL, /* seed */ cluster_labs_rand_bytes, /* bytes */ NULL, /* cleanup */ NULL, /* add */ cluster_labs_rand_bytes, /* pseudorand */ NULL, /* status */ }; static const char *engine_cluster_labs_id = "cluster_labs"; static const char *engine_cluster_labs_name = "Cluster Labs hardware engine support"; /* engine implementation */ /*-----------------------*/ static int bind_helper(ENGINE *e) { if(!ENGINE_set_id(e, engine_cluster_labs_id) || !ENGINE_set_name(e, engine_cluster_labs_name) || #ifndef OPENSSL_NO_RSA !ENGINE_set_RSA(e, &cluster_labs_rsa) || #endif #ifndef OPENSSL_NO_DSA !ENGINE_set_DSA(e, &cluster_labs_dsa) || #endif #ifndef OPENSSL_NO_DH !ENGINE_set_DH(e, &cluster_labs_dh) || #endif !ENGINE_set_RAND(e, &cluster_labs_rand) || !ENGINE_set_destroy_function(e, cluster_labs_destroy) || !ENGINE_set_init_function(e, cluster_labs_init) || !ENGINE_set_finish_function(e, cluster_labs_finish) || !ENGINE_set_ctrl_function(e, cluster_labs_ctrl) || !ENGINE_set_cmd_defns(e, cluster_labs_cmd_defns)) return 0; /* Ensure the error handling is set up */ ERR_load_CL_strings(); return 1; } #ifndef ENGINE_DYNAMIC_SUPPORT static ENGINE *engine_cluster_labs(void) { ENGINE *ret = ENGINE_new(); if(!ret) return NULL; if(!bind_helper(ret)) { ENGINE_free(ret); return NULL; } return ret; } #ifdef ENGINE_DYNAMIC_SUPPORT static #endif void ENGINE_load_cluster_labs(void) { ENGINE *cluster_labs = engine_cluster_labs(); if(!cluster_labs) return; ENGINE_add(cluster_labs); ENGINE_free(cluster_labs); ERR_clear_error(); } #endif /* !ENGINE_DYNAMIC_SUPPORT */ static int cluster_labs_destroy(ENGINE *e) { ERR_unload_CL_strings(); return 1; } /* This is a process-global DSO handle used for loading and unloading * the Cluster Labs library. NB: This is only set (or unset) during an * init() or finish() call (reference counts permitting) and they're * operating with global locks, so this should be thread-safe * implicitly. */ static DSO *cluster_labs_dso = NULL; /* These are the function pointers that are (un)set when the library has * successfully (un)loaded. */ static cl_engine_init *p_cl_engine_init = NULL; static cl_mod_exp *p_cl_mod_exp = NULL; static cl_mod_exp_crt *p_cl_mod_exp_crt = NULL; static cl_rsa_mod_exp *p_cl_rsa_mod_exp = NULL; static cl_rsa_priv_enc *p_cl_rsa_priv_enc = NULL; static cl_rsa_priv_dec *p_cl_rsa_priv_dec = NULL; static cl_rsa_pub_enc *p_cl_rsa_pub_enc = NULL; static cl_rsa_pub_dec *p_cl_rsa_pub_dec = NULL; static cl_rand_bytes *p_cl_rand_bytes = NULL; static cl_dsa_sign *p_cl_dsa_sign = NULL; static cl_dsa_verify *p_cl_dsa_verify = NULL; int cluster_labs_init(ENGINE *e) { cl_engine_init *p1; cl_mod_exp *p2; cl_mod_exp_crt *p3; cl_rsa_mod_exp *p4; cl_rsa_priv_enc *p5; cl_rsa_priv_dec *p6; cl_rsa_pub_enc *p7; cl_rsa_pub_dec *p8; cl_rand_bytes *p20; cl_dsa_sign *p30; cl_dsa_verify *p31; /* engine already loaded */ if(cluster_labs_dso != NULL) { CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_ALREADY_LOADED); goto err; } /* try to load engine */ cluster_labs_dso = DSO_load(NULL, CLUSTER_LABS_LIB_NAME, NULL,0); if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE); goto err; } /* bind functions */ if( !(p1 = (cl_engine_init *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F1)) || !(p2 = (cl_mod_exp *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F2)) || !(p3 = (cl_mod_exp_crt *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F3)) || !(p4 = (cl_rsa_mod_exp *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F4)) || !(p5 = (cl_rsa_priv_enc *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F5)) || !(p6 = (cl_rsa_priv_dec *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F6)) || !(p7 = (cl_rsa_pub_enc *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F7)) || !(p8 = (cl_rsa_pub_dec *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F8)) || !(p20= (cl_rand_bytes *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F20)) || !(p30= (cl_dsa_sign *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F30)) || !(p31= (cl_dsa_verify *)DSO_bind_func( cluster_labs_dso, CLUSTER_LABS_F31))) { CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE); goto err; } /* copy function pointers */ p_cl_engine_init = p1; p_cl_mod_exp = p2; p_cl_mod_exp_crt = p3; p_cl_rsa_mod_exp = p4; p_cl_rsa_priv_enc = p5; p_cl_rsa_priv_dec = p6; p_cl_rsa_pub_enc = p7; p_cl_rsa_pub_dec = p8; p_cl_rand_bytes = p20; p_cl_dsa_sign = p30; p_cl_dsa_verify = p31; /* cluster labs engine init */ if(p_cl_engine_init()== 0){ CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_INIT_FAILED); goto err; } return(1); err: /* reset all pointers */ if(cluster_labs_dso) DSO_free(cluster_labs_dso); cluster_labs_dso = NULL; p_cl_engine_init = NULL; p_cl_mod_exp = NULL; p_cl_mod_exp_crt = NULL; p_cl_rsa_mod_exp = NULL; p_cl_rsa_priv_enc = NULL; p_cl_rsa_priv_dec = NULL; p_cl_rsa_pub_enc = NULL; p_cl_rsa_pub_dec = NULL; p_cl_rand_bytes = NULL; p_cl_dsa_sign = NULL; p_cl_dsa_verify = NULL; return(0); } static int cluster_labs_finish(ENGINE *e) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_FINISH,CL_R_NOT_LOADED); return 0; } if(!DSO_free(cluster_labs_dso)) { CLerr(CL_F_CLUSTER_LABS_FINISH,CL_R_DSO_FAILURE); return 0; } cluster_labs_dso = NULL; p_cl_engine_init = NULL; p_cl_mod_exp = NULL; p_cl_rsa_mod_exp = NULL; p_cl_mod_exp_crt = NULL; p_cl_rsa_priv_enc = NULL; p_cl_rsa_priv_dec = NULL; p_cl_rsa_pub_enc = NULL; p_cl_rsa_pub_dec = NULL; p_cl_rand_bytes = NULL; p_cl_dsa_sign = NULL; p_cl_dsa_verify = NULL; return(1); } static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()) { int initialised = ((cluster_labs_dso == NULL) ? 0 : 1); switch(cmd) { case CLUSTER_LABS_CMD_SO_PATH: if(p == NULL) { CLerr(CL_F_CLUSTER_LABS_CTRL,ERR_R_PASSED_NULL_PARAMETER); return 0; } if(initialised) { CLerr(CL_F_CLUSTER_LABS_CTRL,CL_R_ALREADY_LOADED); return 0; } CLUSTER_LABS_LIB_NAME = (const char *)p; return 1; default: break; } CLerr(CL_F_CLUSTER_LABS_CTRL,CL_R_COMMAND_NOT_IMPLEMENTED); return 0; } static int cluster_labs_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_MOD_EXP,CL_R_NOT_LOADED); return 0; } if(p_cl_mod_exp == NULL) { CLerr(CL_F_CLUSTER_LABS_MOD_EXP,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_mod_exp(r, a, p, m, ctx); } static int cluster_labs_mod_exp_crt(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *q, const BIGNUM *dmp1, const BIGNUM *dmq1, const BIGNUM *iqmp, BN_CTX *ctx) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT,CL_R_NOT_LOADED); return 0; } if(p_cl_mod_exp_crt == NULL) { CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_mod_exp_crt(r, a, p, q,dmp1, dmq1, iqmp, ctx); } static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP,CL_R_NOT_LOADED); return 0; } if(p_cl_rsa_mod_exp == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_rsa_mod_exp(r0, I, rsa); } static DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, DSA *dsa) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_DSA_SIGN,CL_R_NOT_LOADED); return 0; } if(p_cl_dsa_sign == NULL) { CLerr(CL_F_CLUSTER_LABS_DSA_SIGN,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_dsa_sign(dgst, dlen, dsa); } static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len, DSA_SIG *sig, DSA *dsa) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY,CL_R_NOT_LOADED); return 0; } if(p_cl_dsa_verify == NULL) { CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_dsa_verify(dgst, dgst_len, sig, dsa); } static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont) { BIGNUM t; int status = 0; BN_init(&t); /* let rr = a1 ^ p1 mod m */ if (!cluster_labs_mod_exp(rr,a1,p1,m,ctx)) goto end; /* let t = a2 ^ p2 mod m */ if (!cluster_labs_mod_exp(&t,a2,p2,m,ctx)) goto end; /* let rr = rr * t mod m */ if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end; status = 1; end: BN_free(&t); return(1); } static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx) { return cluster_labs_mod_exp(r, a, p, m, ctx); } /* This function is aliased to mod_exp (with the mont stuff dropped). */ static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx) { return cluster_labs_mod_exp(r, a, p, m, ctx); } /* This function is aliased to mod_exp (with the dh and mont dropped). */ static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx) { return cluster_labs_mod_exp(r, a, p, m, ctx); } static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC,CL_R_NOT_LOADED); return 0; } if(p_cl_rsa_priv_enc == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_rsa_pub_enc(flen, from, to, rsa, padding); } static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC,CL_R_NOT_LOADED); return 0; } if(p_cl_rsa_priv_enc == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_rsa_pub_dec(flen, from, to, rsa, padding); } static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC,CL_R_NOT_LOADED); return 0; } if(p_cl_rsa_priv_enc == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_rsa_priv_enc(flen, from, to, rsa, padding); } static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, unsigned char *to, RSA *rsa, int padding) { if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC,CL_R_NOT_LOADED); return 0; } if(p_cl_rsa_priv_dec == NULL) { CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_rsa_priv_dec(flen, from, to, rsa, padding); } /************************************************************************************ * Symmetric algorithms ************************************************************************************/ /* this will be come soon! */ /************************************************************************************ * Random generator ************************************************************************************/ static int cluster_labs_rand_bytes(unsigned char *buf, int num){ if(cluster_labs_dso == NULL) { CLerr(CL_F_CLUSTER_LABS_RAND_BYTES,CL_R_NOT_LOADED); return 0; } if(p_cl_mod_exp_crt == NULL) { CLerr(CL_F_CLUSTER_LABS_RAND_BYTES,CL_R_FUNCTION_NOT_BINDED); return 0; } return p_cl_rand_bytes(buf, num); } /* This stuff is needed if this ENGINE is being compiled into a self-contained * shared-library. */ #ifdef ENGINE_DYNAMIC_SUPPORT static int bind_fn(ENGINE *e, const char *id) { fprintf(stderr, "bind_fn CLUSTER_LABS\n"); if(id && (strcmp(id, engine_cluster_labs_id) != 0)) { fprintf(stderr, "bind_fn return(0) first\n"); return 0; } if(!bind_helper(e)) { fprintf(stderr, "bind_fn return(1) first\n"); return 0; } fprintf(stderr, "bind_fn return(1)\n"); return 1; } IMPLEMENT_DYNAMIC_CHECK_FN() IMPLEMENT_DYNAMIC_BIND_FN(bind_fn) #endif /* ENGINE_DYNAMIC_SUPPORT */ #endif /* !NO_HW_CLUSTER_LABS */ #endif /* !NO_HW */