void
krb5_os_free_context(krb5_context ctx)
{
krb5_os_context os_ctx;
os_ctx = &ctx->os_context;
if (os_ctx->default_ccname) {
free(os_ctx->default_ccname);
os_ctx->default_ccname = 0;
}
os_ctx->magic = 0;
if (ctx->profile) {
profile_release(ctx->profile);
ctx->profile = 0;
}
if (ctx->preauth_context) {
krb5_free_preauth_context(ctx);
ctx->preauth_context = NULL;
}
krb5int_close_plugin_dirs (&ctx->preauth_plugins);
krb5int_close_plugin_dirs (&ctx->libkrb5_plugins);
#ifdef _WIN32
WSACleanup();
#endif /* _WIN32 */
}
void KRB5_CALLCONV
krb5_authdata_context_free(krb5_context kcontext,
krb5_authdata_context context)
{
int i;
if (context == NULL)
return;
for (i = 0; i < context->n_modules; i++) {
struct _krb5_authdata_context_module *module = &context->modules[i];
if (module->client_req_fini != NULL &&
module->request_context != NULL)
(*module->client_req_fini)(kcontext,
context,
module->plugin_context,
module->request_context);
if (module->client_fini != NULL)
(*module->client_fini)(kcontext, module->plugin_context);
memset(module, 0, sizeof(*module));
}
if (context->modules != NULL) {
free(context->modules);
context->modules = NULL;
}
krb5int_close_plugin_dirs(&context->plugins);
memset(context, 0, sizeof(*context));
free(context);
}
static void kim_ui_plugin_context_free (kim_ui_plugin_context *io_context)
{
if (io_context && *io_context) {
if ((*io_context)->ftables) {
krb5int_free_plugin_dir_data ((*io_context)->ftables);
}
if (PLUGIN_DIR_OPEN (&(*io_context)->plugins)) {
krb5int_close_plugin_dirs (&(*io_context)->plugins);
}
if ((*io_context)->kcontext) {
krb5_free_context ((*io_context)->kcontext);
}
free (*io_context);
*io_context = NULL;
}
}
static krb5_error_code
kdb_free_library(db_library lib)
{
krb5_error_code status = 0;
int locked = 0;
if ((status = kdb_lock_list()) != 0) {
goto clean_n_exit;
}
locked = 1;
lib->reference_cnt--;
if (lib->reference_cnt == 0) {
status = lib->vftabl.fini_library();
if (status) {
goto clean_n_exit;
}
/* close the library */
if (PLUGIN_DIR_OPEN((&lib->dl_dir_handle))) {
krb5int_close_plugin_dirs (&lib->dl_dir_handle);
}
kdb_destroy_lib_lock(lib);
if (lib->prev == NULL) {
/* first element in the list */
lib_list = lib->next;
} else {
lib->prev->next = lib->next;
}
if (lib->next) {
lib->next->prev = lib->prev;
}
free(lib);
}
clean_n_exit:
if (locked) {
kdb_unlock_list();
}
return status;
}
krb5_error_code
unload_authdata_plugins(krb5_context context)
{
int i;
if (authdata_systems != NULL) {
for (i = 0; i < n_authdata_systems; i++) {
if (authdata_systems[i].fini != NULL) {
(*authdata_systems[i].fini)(context,
authdata_systems[i].plugin_context);
}
memset(&authdata_systems[i], 0, sizeof(authdata_systems[i]));
}
free(authdata_systems);
authdata_systems = NULL;
n_authdata_systems = 0;
krb5int_close_plugin_dirs(&authdata_plugins);
}
return 0;
}
static krb5_error_code
kdb_load_library(krb5_context kcontext, char *lib_name, db_library * lib)
{
krb5_error_code status = 0;
int ndx;
void **vftabl_addrs = NULL;
/* N.B.: If this is "const" but not "static", the Solaris 10
native compiler has trouble building the library because of
absolute relocations needed in read-only section ".rodata".
When it's static, it goes into ".picdata", which is
read-write. */
static const char *const dbpath_names[] = {
KDB_MODULE_SECTION, "db_module_dir", NULL,
};
const char *filebases[2];
char **profpath = NULL;
char **path = NULL;
filebases[0] = lib_name;
filebases[1] = NULL;
if (!strcmp(DB2_NAME, lib_name) && (kdb_db2_pol_err_loaded == 0)) {
initialize_adb_error_table();
kdb_db2_pol_err_loaded = 1;
}
*lib = calloc((size_t) 1, sizeof(**lib));
if (*lib == NULL) {
status = ENOMEM;
goto clean_n_exit;
}
status = kdb_init_lib_lock(*lib);
if (status) {
goto clean_n_exit;
}
strcpy((*lib)->name, lib_name);
/* Fetch the list of directories specified in the config
file(s) first. */
status = profile_get_values(kcontext->profile, dbpath_names, &profpath);
if (status != 0 && status != PROF_NO_RELATION)
goto clean_n_exit;
ndx = 0;
if (profpath)
while (profpath[ndx] != NULL)
ndx++;
path = calloc(ndx + db_dl_n_locations, sizeof (char *));
if (path == NULL) {
status = errno;
goto clean_n_exit;
}
if (ndx)
memcpy(path, profpath, ndx * sizeof(profpath[0]));
memcpy(path + ndx, db_dl_location, db_dl_n_locations * sizeof(char *));
status = 0;
if ((status = krb5int_open_plugin_dirs ((const char **) path,
filebases,
&(*lib)->dl_dir_handle, &kcontext->err))) {
char *err_str = krb5_get_error_message(kcontext, status);
status = KRB5_KDB_DBTYPE_NOTFOUND;
krb5_set_error_message (kcontext, status,
"Unable to find requested database type: %s", err_str);
krb5_free_error_message (kcontext, err_str);
goto clean_n_exit;
}
if ((status = krb5int_get_plugin_dir_data (&(*lib)->dl_dir_handle, "kdb_function_table",
&vftabl_addrs, &kcontext->err))) {
char *err_str = krb5_get_error_message(kcontext, status);
status = KRB5_KDB_DBTYPE_INIT;
krb5_set_error_message (kcontext, status,
"plugin symbol 'kdb_function_table' lookup failed: %s", err_str);
krb5_free_error_message (kcontext, err_str);
goto clean_n_exit;
}
if (vftabl_addrs[0] == NULL) {
/* No plugins! */
status = KRB5_KDB_DBTYPE_NOTFOUND;
krb5_set_error_message (kcontext, status,
_("Unable to load requested database module '%s': plugin symbol 'kdb_function_table' not found"),
lib_name);
goto clean_n_exit;
}
memcpy(&(*lib)->vftabl, vftabl_addrs[0], sizeof(kdb_vftabl));
kdb_setup_opt_functions(*lib);
if ((status = (*lib)->vftabl.init_library())) {
/* ERROR. library not initialized cleanly */
goto clean_n_exit;
}
clean_n_exit:
if (vftabl_addrs != NULL) { krb5int_free_plugin_dir_data (vftabl_addrs); }
/* Both of these DTRT with NULL. */
profile_free_list(profpath);
free(path);
if (status) {
if (*lib) {
kdb_destroy_lib_lock(*lib);
if (PLUGIN_DIR_OPEN((&(*lib)->dl_dir_handle))) {
krb5int_close_plugin_dirs (&(*lib)->dl_dir_handle);
}
free(*lib);
*lib = NULL;
}
}
return status;
}
krb5_error_code KRB5_CALLCONV
krb5_authdata_context_init(krb5_context kcontext,
krb5_authdata_context *pcontext)
{
int n_modules, n_tables, i, k;
void **tables = NULL;
krb5plugin_authdata_client_ftable_v0 *table;
krb5_authdata_context context = NULL;
int internal_count = 0;
struct plugin_dir_handle plugins;
krb5_error_code code;
*pcontext = NULL;
memset(&plugins, 0, sizeof(plugins));
n_modules = 0;
for (n_tables = 0; authdata_systems[n_tables] != NULL; n_tables++) {
n_modules += k5_ad_module_count(authdata_systems[n_tables]);
}
internal_count = n_tables;
if (PLUGIN_DIR_OPEN(&plugins) == 0 &&
krb5int_open_plugin_dirs(objdirs, NULL,
&plugins,
&kcontext->err) == 0 &&
krb5int_get_plugin_dir_data(&plugins,
"authdata_client_0",
&tables,
&kcontext->err) == 0 &&
tables != NULL)
{
for (; tables[n_tables - internal_count] != NULL; n_tables++) {
table = tables[n_tables - internal_count];
n_modules += k5_ad_module_count(table);
}
}
context = calloc(1, sizeof(*context));
if (kcontext == NULL) {
code = ENOMEM;
goto cleanup;
}
context->magic = KV5M_AUTHDATA_CONTEXT;
context->modules = calloc(n_modules, sizeof(context->modules[0]));
if (context->modules == NULL) {
code = ENOMEM;
goto cleanup;
}
context->n_modules = n_modules;
/* fill in the structure */
for (i = 0, k = 0, code = 0; i < n_tables - internal_count; i++) {
code = k5_ad_init_modules(kcontext, context, tables[i], &k);
if (code != 0)
goto cleanup;
}
for (i = 0; i < internal_count; i++) {
code = k5_ad_init_modules(kcontext, context, authdata_systems[i], &k);
if (code != 0)
goto cleanup;
}
context->plugins = plugins;
cleanup:
if (tables != NULL)
krb5int_free_plugin_dir_data(tables);
if (code != 0) {
krb5int_close_plugin_dirs(&plugins);
krb5_authdata_context_free(kcontext, context);
} else {
/* plugins is owned by context now */
*pcontext = context;
}
return code;
}
