static int
tlso_verify_cb( int ok, X509_STORE_CTX *ctx )
{
X509 *cert;
int errnum;
int errdepth;
X509_NAME *subject;
X509_NAME *issuer;
char *sname;
char *iname;
char *certerr = NULL;
cert = X509_STORE_CTX_get_current_cert( ctx );
errnum = X509_STORE_CTX_get_error( ctx );
errdepth = X509_STORE_CTX_get_error_depth( ctx );
/*
* X509_get_*_name return pointers to the internal copies of
* those things requested. So do not free them.
*/
subject = X509_get_subject_name( cert );
issuer = X509_get_issuer_name( cert );
/* X509_NAME_oneline, if passed a NULL buf, allocate memomry */
sname = X509_NAME_oneline( subject, NULL, 0 );
iname = X509_NAME_oneline( issuer, NULL, 0 );
if ( !ok ) certerr = (char *)X509_verify_cert_error_string( errnum );
#ifdef HAVE_EBCDIC
if ( sname ) __etoa( sname );
if ( iname ) __etoa( iname );
if ( certerr ) {
certerr = LDAP_STRDUP( certerr );
__etoa( certerr );
}
#endif
Debug( LDAP_DEBUG_TRACE,
"TLS certificate verification: depth: %d, err: %d, subject: %s,",
errdepth, errnum,
sname ? sname : "-unknown-" );
Debug( LDAP_DEBUG_TRACE, " issuer: %s\n", iname ? iname : "-unknown-", 0, 0 );
if ( !ok ) {
Debug( LDAP_DEBUG_ANY,
"TLS certificate verification: Error, %s\n",
certerr, 0, 0 );
}
if ( sname )
CRYPTO_free ( sname );
if ( iname )
CRYPTO_free ( iname );
#ifdef HAVE_EBCDIC
if ( certerr ) LDAP_FREE( certerr );
#endif
return ok;
}
char* lutil_progname( const char* name, int argc, char *argv[] )
{
char *progname;
if(argc == 0) {
return (char *)name;
}
#ifdef HAVE_EBCDIC
if (_trans_argv) {
int i;
for (i=0; i<argc; i++) __etoa(argv[i]);
_trans_argv = 0;
}
#endif
LUTIL_SLASHPATH( argv[0] );
progname = strrchr ( argv[0], *LDAP_DIRSEP );
progname = progname ? &progname[1] : argv[0];
#ifdef _WIN32
{
size_t len = strlen( progname );
if ( len > 4 && strcasecmp( &progname[len - 4], ".exe" ) == 0 )
progname[len - 4] = '\0';
}
#endif
return progname;
}
String System::getHostIP(const String &hostName)
{
struct hostent * phostent;
struct in_addr inaddr;
String ipAddress = String::EMPTY;
CString csName = hostName.getCString();
const char * ccName = csName;
#ifndef PEGASUS_OS_OS400
if ((phostent = ::gethostbyname(ccName)) != NULL)
#else
char ebcdicHost[PEGASUS_MAXHOSTNAMELEN];
if (strlen(ccName) < PEGASUS_MAXHOSTNAMELEN)
strcpy(ebcdicHost, ccName);
else
return ipAddress;
AtoE(ebcdicHost);
if ((phostent = ::gethostbyname(ebcdicHost)) != NULL)
#endif
{
::memcpy( &inaddr, phostent->h_addr,4);
#ifdef PEGASUS_PLATFORM_ZOS_ZSERIES_IBM
char * gottenIPAdress = NULL;
gottenIPAdress = ::inet_ntoa( inaddr );
__etoa(gottenIPAdress);
if (gottenIPAdress != NULL)
{
ipAddress.assign(gottenIPAdress);
}
#else
ipAddress = ::inet_ntoa( inaddr );
#endif
}
return ipAddress;
}
void bdb_msgcall( const DB_ENV *env, const char *msg )
{
#ifdef HAVE_EBCDIC
if ( msg[0] > 0x7f )
__etoa( msg );
#endif
Debug( LDAP_DEBUG_TRACE, "bdb: %s\n", msg, 0, 0 );
}
/* Not re-entrant! */
char *ebcdic_dberror( int rc )
{
static char msg[1024];
strcpy( msg, db_strerror( rc ) );
__etoa( msg );
return msg;
}
void bdb_errcall( const DB_ENV *env, const char *pfx, const char * msg )
#endif
{
#ifdef HAVE_EBCDIC
if ( msg[0] > 0x7f )
__etoa( msg );
#endif
Debug( LDAP_DEBUG_ANY, "bdb(%s): %s\n", pfx, msg, 0 );
}
/* Inspired by ERR_print_errors in OpenSSL */
static void
tlso_report_error( void )
{
unsigned long l;
char buf[200];
const char *file;
int line;
while ( ( l = ERR_get_error_line( &file, &line ) ) != 0 ) {
ERR_error_string_n( l, buf, sizeof( buf ) );
#ifdef HAVE_EBCDIC
if ( file ) {
file = LDAP_STRDUP( file );
__etoa( (char *)file );
}
__etoa( buf );
#endif
Debug( LDAP_DEBUG_ANY, "TLS: %s %s:%d\n",
buf, file, line );
#ifdef HAVE_EBCDIC
if ( file ) LDAP_FREE( (void *)file );
#endif
}
}
int module_init (void)
{
if (lt_dlinit()) {
const char *error = lt_dlerror();
#ifdef HAVE_EBCDIC
strcpy( ebuf, error );
__etoa( ebuf );
error = ebuf;
#endif
Debug(LDAP_DEBUG_ANY, "lt_dlinit failed: %s\n", error, 0, 0);
return -1;
}
return module_path( LDAP_MODULEDIR );
}
size_t lutil_gentime( char *s, size_t smax, const struct tm *tm )
{
size_t ret;
#ifdef HAVE_EBCDIC
/* We've been compiling in ASCII so far, but we want EBCDIC now since
* strftime only understands EBCDIC input.
*/
#pragma convlit(suspend)
#endif
ret = strftime( s, smax, "%Y%m%d%H%M%SZ", tm );
#ifdef HAVE_EBCDIC
#pragma convlit(resume)
__etoa( s );
#endif
return ret;
}
size_t lutil_localtime( char *s, size_t smax, const struct tm *tm, long delta )
{
size_t ret;
char *p;
if ( smax < 16 ) { /* YYYYmmddHHMMSSZ */
return 0;
}
#ifdef HAVE_EBCDIC
/* We've been compiling in ASCII so far, but we want EBCDIC now since
* strftime only understands EBCDIC input.
*/
#pragma convlit(suspend)
#endif
ret = strftime( s, smax, "%Y%m%d%H%M%SZ", tm );
#ifdef HAVE_EBCDIC
#pragma convlit(resume)
__etoa( s );
#endif
if ( delta == 0 || ret == 0 ) {
return ret;
}
if ( smax < 20 ) { /* YYYYmmddHHMMSS+HHMM */
return 0;
}
p = s + 14;
if ( delta < 0 ) {
p[ 0 ] = '-';
delta = -delta;
} else {
p[ 0 ] = '+';
}
p++;
snprintf( p, smax - 15, "%02ld%02ld", delta / 3600,
( delta % 3600 ) / 60 );
return ret + 4;
}
char* lutil_progname( const char* name, int argc, char *argv[] )
{
char *progname;
if(argc == 0) {
return (char *)name;
}
#ifdef HAVE_EBCDIC
if (_trans_argv) {
int i;
for (i=0; i<argc; i++) __etoa(argv[i]);
_trans_argv = 0;
}
#endif
LUTIL_SLASHPATH( argv[0] );
progname = strrchr ( argv[0], *LDAP_DIRSEP );
progname = progname ? &progname[1] : argv[0];
return progname;
}
int module_kill (void)
{
/* unload all modules before shutdown */
while (module_list != NULL) {
module_int_unload(module_list);
}
if (lt_dlexit()) {
const char *error = lt_dlerror();
#ifdef HAVE_EBCDIC
strcpy( ebuf, error );
__etoa( ebuf );
error = ebuf;
#endif
Debug(LDAP_DEBUG_ANY, "lt_dlexit failed: %s\n", error, 0, 0);
return -1;
}
return 0;
}
char *ber_pvt_fgets( char *s, int n, FILE *fp )
{
s = (char *)fgets( s, n, fp );
if ( s ) __etoa( s );
return s;
}
int getopt (int argc, char * const argv [], const char * opts)
{
static int sp = 1, error = (int) '?';
static char sw = '-', eos = '\0', arg = ':';
register char c, * cp;
#ifdef DF_TRACE_DEBUG
printf("DF_TRACE_DEBUG: int getopt () in getopt.c\n");
#endif
#ifdef HAVE_EBCDIC
if (_trans_argv) {
int i;
for (i=0; i<argc; i++) __etoa(argv[i]);
_trans_argv = 0;
}
#endif
if (sp == 1)
{
if (optind >= argc || argv[optind][0] != sw
|| argv[optind][1] == eos)
return EOF;
else if (strcmp(argv[optind],"--") == 0)
{
optind++;
return EOF;
}
}
c = argv[optind][sp];
optopt = (int) c;
if (c == arg || (cp = strchr(opts,c)) == NULL)
{
ERR(argv,_(": illegal option--"),c);
if (argv[optind][++sp] == eos)
{
optind++;
sp = 1;
}
return error;
}
else if (*++cp == arg)
{
if (argv[optind][sp + 1] != eos)
optarg = &argv[optind++][sp + 1];
else if (++optind >= argc)
{
ERR(argv,_(": option requires an argument--"),c);
sp = 1;
return error;
}
else
optarg = argv[optind++];
sp = 1;
}
else
{
if (argv[optind][++sp] == eos)
{
sp = 1;
optind++;
}
optarg = NULL;
}
return (int) c;
}
static int
ldap_int_tls_connect( LDAP *ld, LDAPConn *conn )
{
Sockbuf *sb = conn->lconn_sb;
int err;
tls_session *ssl = NULL;
if ( HAS_TLS( sb )) {
ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
} else {
struct ldapoptions *lo;
tls_ctx *ctx;
ctx = ld->ld_options.ldo_tls_ctx;
ssl = alloc_handle( ctx, 0 );
if ( ssl == NULL ) return -1;
#ifdef LDAP_DEBUG
ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
#endif
ber_sockbuf_add_io( sb, tls_imp->ti_sbio,
LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
lo = LDAP_INT_GLOBAL_OPT();
if( ctx == NULL ) {
ctx = lo->ldo_tls_ctx;
ld->ld_options.ldo_tls_ctx = ctx;
tls_ctx_ref( ctx );
}
if ( ld->ld_options.ldo_tls_connect_cb )
ld->ld_options.ldo_tls_connect_cb( ld, ssl, ctx,
ld->ld_options.ldo_tls_connect_arg );
if ( lo && lo->ldo_tls_connect_cb && lo->ldo_tls_connect_cb !=
ld->ld_options.ldo_tls_connect_cb )
lo->ldo_tls_connect_cb( ld, ssl, ctx, lo->ldo_tls_connect_arg );
}
err = tls_imp->ti_session_connect( ld, ssl );
#ifdef HAVE_WINSOCK
errno = WSAGetLastError();
#endif
if ( err < 0 )
{
char buf[256], *msg;
if ( update_flags( sb, ssl, err )) {
return 1;
}
msg = tls_imp->ti_session_errmsg( ssl, err, buf, sizeof(buf) );
if ( msg ) {
if ( ld->ld_error ) {
LDAP_FREE( ld->ld_error );
}
ld->ld_error = LDAP_STRDUP( msg );
#ifdef HAVE_EBCDIC
if ( ld->ld_error ) __etoa(ld->ld_error);
#endif
}
Debug( LDAP_DEBUG_ANY,"TLS: can't connect: %s.\n",
ld->ld_error ? ld->ld_error : "" ,0,0);
ber_sockbuf_remove_io( sb, tls_imp->ti_sbio,
LBER_SBIOD_LEVEL_TRANSPORT );
#ifdef LDAP_DEBUG
ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
LBER_SBIOD_LEVEL_TRANSPORT );
#endif
return -1;
}
return 0;
}
int
mdb_back_initialize(
BackendInfo *bi )
{
int rc;
static char *controls[] = {
LDAP_CONTROL_ASSERT,
LDAP_CONTROL_MANAGEDSAIT,
LDAP_CONTROL_NOOP,
LDAP_CONTROL_PAGEDRESULTS,
LDAP_CONTROL_PRE_READ,
LDAP_CONTROL_POST_READ,
LDAP_CONTROL_SUBENTRIES,
LDAP_CONTROL_X_PERMISSIVE_MODIFY,
#ifdef LDAP_X_TXN
LDAP_CONTROL_X_TXN_SPEC,
#endif
NULL
};
/* initialize the underlying database system */
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(mdb_back_initialize) ": initialize "
MDB_UCTYPE " backend\n", 0, 0, 0 );
bi->bi_flags |=
SLAP_BFLAG_INCREMENT |
SLAP_BFLAG_SUBENTRIES |
SLAP_BFLAG_ALIASES |
SLAP_BFLAG_REFERRALS;
bi->bi_controls = controls;
{ /* version check */
int major, minor, patch, ver;
char *version = mdb_version( &major, &minor, &patch );
#ifdef HAVE_EBCDIC
char v2[1024];
/* All our stdio does an ASCII to EBCDIC conversion on
* the output. Strings from the MDB library are already
* in EBCDIC; we have to go back and forth...
*/
strcpy( v2, version );
__etoa( v2 );
version = v2;
#endif
ver = (major << 24) | (minor << 16) | patch;
if( ver != MDB_VERSION_FULL ) {
/* fail if a versions don't match */
Debug( LDAP_DEBUG_ANY,
LDAP_XSTRING(mdb_back_initialize) ": "
"MDB library version mismatch:"
" expected " MDB_VERSION_STRING ","
" got %s\n", version, 0, 0 );
return -1;
}
Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(mdb_back_initialize)
": %s\n", version, 0, 0 );
}
bi->bi_open = 0;
bi->bi_close = 0;
bi->bi_config = 0;
bi->bi_destroy = 0;
bi->bi_db_init = mdb_db_init;
bi->bi_db_config = config_generic_wrapper;
bi->bi_db_open = mdb_db_open;
bi->bi_db_close = mdb_db_close;
bi->bi_db_destroy = mdb_db_destroy;
bi->bi_op_add = mdb_add;
bi->bi_op_bind = mdb_bind;
bi->bi_op_compare = mdb_compare;
bi->bi_op_delete = mdb_delete;
bi->bi_op_modify = mdb_modify;
bi->bi_op_modrdn = mdb_modrdn;
bi->bi_op_search = mdb_search;
bi->bi_op_unbind = 0;
bi->bi_op_txn = mdb_txn;
bi->bi_extended = mdb_extended;
bi->bi_chk_referrals = 0;
bi->bi_operational = mdb_operational;
bi->bi_has_subordinates = mdb_hasSubordinates;
bi->bi_entry_release_rw = mdb_entry_release;
bi->bi_entry_get_rw = mdb_entry_get;
/*
* hooks for slap tools
*/
bi->bi_tool_entry_open = mdb_tool_entry_open;
bi->bi_tool_entry_close = mdb_tool_entry_close;
bi->bi_tool_entry_first = backend_tool_entry_first;
bi->bi_tool_entry_first_x = mdb_tool_entry_first_x;
bi->bi_tool_entry_next = mdb_tool_entry_next;
bi->bi_tool_entry_get = mdb_tool_entry_get;
bi->bi_tool_entry_put = mdb_tool_entry_put;
bi->bi_tool_entry_reindex = mdb_tool_entry_reindex;
bi->bi_tool_sync = 0;
bi->bi_tool_dn2id_get = mdb_tool_dn2id_get;
bi->bi_tool_entry_modify = mdb_tool_entry_modify;
bi->bi_connection_init = 0;
bi->bi_connection_destroy = 0;
rc = mdb_back_init_cf( bi );
return rc;
}
int
bdb_back_initialize(
BackendInfo *bi )
{
int rc;
static char *controls[] = {
LDAP_CONTROL_ASSERT,
LDAP_CONTROL_MANAGEDSAIT,
LDAP_CONTROL_NOOP,
LDAP_CONTROL_PAGEDRESULTS,
LDAP_CONTROL_PRE_READ,
LDAP_CONTROL_POST_READ,
LDAP_CONTROL_SUBENTRIES,
LDAP_CONTROL_X_PERMISSIVE_MODIFY,
#ifdef LDAP_X_TXN
LDAP_CONTROL_X_TXN_SPEC,
#endif
NULL
};
/* initialize the underlying database system */
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(bdb_back_initialize) ": initialize "
BDB_UCTYPE " backend\n", 0, 0, 0 );
bi->bi_flags |=
SLAP_BFLAG_INCREMENT |
SLAP_BFLAG_SUBENTRIES |
SLAP_BFLAG_ALIASES |
SLAP_BFLAG_REFERRALS;
bi->bi_controls = controls;
{ /* version check */
int major, minor, patch, ver;
char *version = db_version( &major, &minor, &patch );
#ifdef HAVE_EBCDIC
char v2[1024];
/* All our stdio does an ASCII to EBCDIC conversion on
* the output. Strings from the BDB library are already
* in EBCDIC; we have to go back and forth...
*/
strcpy( v2, version );
__etoa( v2 );
version = v2;
#endif
ver = (major << 24) | (minor << 16) | patch;
if( ver != DB_VERSION_FULL ) {
/* fail if a versions don't match */
Debug( LDAP_DEBUG_ANY,
LDAP_XSTRING(bdb_back_initialize) ": "
"BDB library version mismatch:"
" expected " DB_VERSION_STRING ","
" got %s\n", version, 0, 0 );
return -1;
}
Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_back_initialize)
": %s\n", version, 0, 0 );
}
db_env_set_func_free( ber_memfree );
db_env_set_func_malloc( (db_malloc *)ber_memalloc );
db_env_set_func_realloc( (db_realloc *)ber_memrealloc );
#if !defined(NO_THREAD) && DB_VERSION_FULL <= 0x04070000
/* This is a no-op on a NO_THREAD build. Leave the default
* alone so that BDB will sleep on interprocess conflicts.
* Don't bother on BDB 4.7...
*/
db_env_set_func_yield( ldap_pvt_thread_yield );
#endif
bi->bi_open = 0;
bi->bi_close = 0;
bi->bi_config = 0;
bi->bi_destroy = 0;
bi->bi_db_init = bdb_db_init;
bi->bi_db_config = config_generic_wrapper;
bi->bi_db_open = bdb_db_open;
bi->bi_db_close = bdb_db_close;
bi->bi_db_destroy = bdb_db_destroy;
bi->bi_op_add = bdb_add;
bi->bi_op_bind = bdb_bind;
bi->bi_op_compare = bdb_compare;
bi->bi_op_delete = bdb_delete;
bi->bi_op_modify = bdb_modify;
bi->bi_op_modrdn = bdb_modrdn;
bi->bi_op_search = bdb_search;
bi->bi_op_unbind = 0;
bi->bi_extended = bdb_extended;
bi->bi_chk_referrals = bdb_referrals;
bi->bi_operational = bdb_operational;
bi->bi_has_subordinates = bdb_hasSubordinates;
bi->bi_entry_release_rw = bdb_entry_release;
bi->bi_entry_get_rw = bdb_entry_get;
/*
* hooks for slap tools
*/
bi->bi_tool_entry_open = bdb_tool_entry_open;
bi->bi_tool_entry_close = bdb_tool_entry_close;
bi->bi_tool_entry_first = backend_tool_entry_first;
bi->bi_tool_entry_first_x = bdb_tool_entry_first_x;
bi->bi_tool_entry_next = bdb_tool_entry_next;
bi->bi_tool_entry_get = bdb_tool_entry_get;
bi->bi_tool_entry_put = bdb_tool_entry_put;
bi->bi_tool_entry_reindex = bdb_tool_entry_reindex;
bi->bi_tool_sync = 0;
bi->bi_tool_dn2id_get = bdb_tool_dn2id_get;
bi->bi_tool_entry_modify = bdb_tool_entry_modify;
bi->bi_connection_init = 0;
bi->bi_connection_destroy = 0;
rc = bdb_back_init_cf( bi );
return rc;
}
/* Derived from openssl/apps/s_cb.c */
static void
tlso_info_cb( const SSL *ssl, int where, int ret )
{
int w;
char *op;
char *state = (char *) SSL_state_string_long( (SSL *)ssl );
w = where & ~SSL_ST_MASK;
if ( w & SSL_ST_CONNECT ) {
op = "SSL_connect";
} else if ( w & SSL_ST_ACCEPT ) {
op = "SSL_accept";
} else {
op = "undefined";
}
#ifdef HAVE_EBCDIC
if ( state ) {
state = LDAP_STRDUP( state );
__etoa( state );
}
#endif
if ( where & SSL_CB_LOOP ) {
Debug( LDAP_DEBUG_TRACE,
"TLS trace: %s:%s\n",
op, state, 0 );
} else if ( where & SSL_CB_ALERT ) {
char *atype = (char *) SSL_alert_type_string_long( ret );
char *adesc = (char *) SSL_alert_desc_string_long( ret );
op = ( where & SSL_CB_READ ) ? "read" : "write";
#ifdef HAVE_EBCDIC
if ( atype ) {
atype = LDAP_STRDUP( atype );
__etoa( atype );
}
if ( adesc ) {
adesc = LDAP_STRDUP( adesc );
__etoa( adesc );
}
#endif
Debug( LDAP_DEBUG_TRACE,
"TLS trace: SSL3 alert %s:%s:%s\n",
op, atype, adesc );
#ifdef HAVE_EBCDIC
if ( atype ) LDAP_FREE( atype );
if ( adesc ) LDAP_FREE( adesc );
#endif
} else if ( where & SSL_CB_EXIT ) {
if ( ret == 0 ) {
Debug( LDAP_DEBUG_TRACE,
"TLS trace: %s:failed in %s\n",
op, state, 0 );
} else if ( ret < 0 ) {
Debug( LDAP_DEBUG_TRACE,
"TLS trace: %s:error in %s\n",
op, state, 0 );
}
}
#ifdef HAVE_EBCDIC
if ( state ) LDAP_FREE( state );
#endif
}
int module_load(const char* file_name, int argc, char *argv[])
{
module_loaded_t *module;
const char *error;
int rc;
MODULE_INIT_FN initialize;
#ifdef HAVE_EBCDIC
#define file ebuf
#else
#define file file_name
#endif
module = module_handle( file_name );
if ( module ) {
Debug( LDAP_DEBUG_ANY, "module_load: (%s) already loaded\n",
file_name, 0, 0 );
return -1;
}
/* If loading a backend, see if we already have it */
if ( !strncasecmp( file_name, "back_", 5 )) {
char *name = (char *)file_name + 5;
char *dot = strchr( name, '.');
if (dot) *dot = '\0';
rc = backend_info( name ) != NULL;
if (dot) *dot = '.';
if ( rc ) {
Debug( LDAP_DEBUG_CONFIG, "module_load: (%s) already present (static)\n",
file_name, 0, 0 );
return 0;
}
} else {
/* check for overlays too */
char *dot = strchr( file_name, '.' );
if ( dot ) *dot = '\0';
rc = overlay_find( file_name ) != NULL;
if ( dot ) *dot = '.';
if ( rc ) {
Debug( LDAP_DEBUG_CONFIG, "module_load: (%s) already present (static)\n",
file_name, 0, 0 );
return 0;
}
}
module = (module_loaded_t *)ch_calloc(1, sizeof(module_loaded_t) +
strlen(file_name));
if (module == NULL) {
Debug(LDAP_DEBUG_ANY, "module_load failed: (%s) out of memory\n", file_name,
0, 0);
return -1;
}
strcpy( module->name, file_name );
#ifdef HAVE_EBCDIC
strcpy( file, file_name );
__atoe( file );
#endif
/*
* The result of lt_dlerror(), when called, must be cached prior
* to calling Debug. This is because Debug is a macro that expands
* into multiple function calls.
*/
if ((module->lib = lt_dlopenext(file)) == NULL) {
error = lt_dlerror();
#ifdef HAVE_EBCDIC
strcpy( ebuf, error );
__etoa( ebuf );
error = ebuf;
#endif
Debug(LDAP_DEBUG_ANY, "lt_dlopenext failed: (%s) %s\n", file_name,
error, 0);
ch_free(module);
return -1;
}
Debug(LDAP_DEBUG_CONFIG, "loaded module %s\n", file_name, 0, 0);
#ifdef HAVE_EBCDIC
#pragma convlit(suspend)
#endif
if ((initialize = lt_dlsym(module->lib, "init_module")) == NULL) {
#ifdef HAVE_EBCDIC
#pragma convlit(resume)
#endif
Debug(LDAP_DEBUG_CONFIG, "module %s: no init_module() function found\n",
file_name, 0, 0);
lt_dlclose(module->lib);
ch_free(module);
return -1;
}
/* The imported init_module() routine passes back the type of
* module (i.e., which part of slapd it should be hooked into)
* or -1 for error. If it passes back 0, then you get the
* old behavior (i.e., the library is loaded and not hooked
* into anything).
*
* It might be better if the conf file could specify the type
* of module. That way, a single module could support multiple
* type of hooks. This could be done by using something like:
*
* moduleload extension /usr/local/openldap/whatever.so
*
* then we'd search through module_regtable for a matching
* module type, and hook in there.
*/
rc = initialize(argc, argv);
if (rc == -1) {
Debug(LDAP_DEBUG_CONFIG, "module %s: init_module() failed\n",
file_name, 0, 0);
lt_dlclose(module->lib);
ch_free(module);
return rc;
}
if (rc >= (int)(sizeof(module_regtable) / sizeof(struct module_regtable_t))
|| module_regtable[rc].proc == NULL)
{
Debug(LDAP_DEBUG_CONFIG, "module %s: unknown registration type (%d)\n",
file_name, rc, 0);
module_int_unload(module);
return -1;
}
rc = (module_regtable[rc].proc)(module, file_name);
if (rc != 0) {
Debug(LDAP_DEBUG_CONFIG, "module %s: %s module could not be registered\n",
file_name, module_regtable[rc].type, 0);
module_int_unload(module);
return rc;
}
module->next = module_list;
module_list = module;
Debug(LDAP_DEBUG_CONFIG, "module %s: %s module registered\n",
file_name, module_regtable[rc].type, 0);
return 0;
}
