void khm_cred_destroy_creds(khm_boolean sync, khm_boolean quiet)
{
khui_action_context * pctx;
pctx = PMALLOC(sizeof(*pctx));
#ifdef DEBUG
assert(pctx);
#endif
khui_context_get(pctx);
if(pctx->scope == KHUI_SCOPE_NONE && !quiet) {
/* this really shouldn't be necessary once we start enabling
and disbling actions based on context */
wchar_t title[256];
wchar_t message[256];
LoadString(khm_hInstance,
IDS_ALERT_NOSEL_TITLE,
title,
ARRAYLENGTH(title));
LoadString(khm_hInstance,
IDS_ALERT_NOSEL,
message,
ARRAYLENGTH(message));
khui_alert_show_simple(title,
message,
KHERR_WARNING);
khui_context_release(pctx);
PFREE(pctx);
return;
}
_begin_task(KHERR_CF_TRANSITIVE);
_report_sr0(KHERR_NONE, IDS_CTX_DESTROY_CREDS);
_describe();
if (sync)
kmq_send_message(KMSG_CRED,
KMSG_CRED_DESTROY_CREDS,
0,
(void *) pctx);
else
kmq_post_message(KMSG_CRED,
KMSG_CRED_DESTROY_CREDS,
0,
(void *) pctx);
_end_task();
}
KHMEXP khm_int32 KHMAPI
khui_alert_monitor_progress(khui_alert * alert,
kherr_context * ctx,
khm_int32 monitor_flags)
{
khm_int32 rv = KHM_ERROR_SUCCESS;
kherr_event * e;
khm_boolean release_context = FALSE;
if (ctx == NULL) {
ctx = kherr_peek_context();
release_context = TRUE;
}
if (ctx == NULL) {
return KHM_ERROR_INVALID_OPERATION;
}
e = kherr_get_desc_event(ctx);
if (e) {
if (e->short_desc && e->long_desc) {
khui_alert_set_title(alert, e->short_desc);
khui_alert_set_message(alert, e->long_desc);
} else if (e->short_desc) {
khui_alert_set_title(alert, e->short_desc);
} else if (e->long_desc) {
khui_alert_set_title(alert, e->long_desc);
}
}
kherr_hold_context(ctx);
EnterCriticalSection(&cs_alerts);
alert->err_context = ctx;
alert->monitor_flags = monitor_flags;
if (alert->alert_type == KHUI_ALERTTYPE_NONE)
alert->alert_type = KHUI_ALERTTYPE_PROGRESS;
alert->flags |= (KHUI_ALERT_FLAG_MODIFIED | KHUI_ALERT_FLAG_VALID_ERROR);
LeaveCriticalSection(&cs_alerts);
if (release_context && ctx)
kherr_release_context(ctx);
khui_alert_hold(alert);
rv = kmq_send_message(KMSG_ALERT, KMSG_ALERT_MONITOR_PROGRESS, 0,
(void *) alert);
return rv;
}
KHMEXP khm_int32 KHMAPI
khui_alert_show_modal(khui_alert * alert)
{
khm_int32 rv;
assert(alert->magic == KHUI_ALERT_MAGIC);
khui_alert_hold(alert);
rv = kmq_send_message(KMSG_ALERT, KMSG_ALERT_SHOW_MODAL, 0,
(void *) alert);
return rv;
}
/* Handler for system messages. The only two we handle are
KMSG_SYSTEM_INIT and KMSG_SYSTEM_EXIT. */
khm_int32 KHMAPI
handle_kmsg_system(khm_int32 msg_type,
khm_int32 msg_subtype,
khm_ui_4 uparam,
void * vparam) {
khm_int32 rv = KHM_ERROR_SUCCESS;
switch (msg_subtype) {
/* This is the first message that will be received by a
plugin. We use it to perform initialization operations
such as registering any credential types, data types and
attributes. */
case KMSG_SYSTEM_INIT:
{
wchar_t short_desc[KCDB_MAXCCH_SHORT_DESC];
wchar_t long_desc[KCDB_MAXCCH_LONG_DESC];
#ifdef USE_CONFIGURATION_PANELS
khui_config_node_reg creg;
#endif
afs_msg_announce announce;
if (KHM_FAILED(kmq_find_type(AFS_MSG_TYPENAME, &msg_type_afs))) {
return KHM_ERROR_UNKNOWN;
}
/* We must first announce our extension plug-in, so that
the AFS plug-in will know we exist */
announce.cbsize = sizeof(announce);
announce.version = AFS_PLUGIN_VERSION;
announce.name = MYPLUGIN_NAMEW;
kmq_create_subscription(handle_AFS_MSG, &announce.sub);
/* Set to TRUE if we are providing a token acquisition
method */
announce.provide_token_acq = TRUE;
LoadString(hResModule, IDS_TKMETHOD_SHORT_DESC,
short_desc, ARRAYLENGTH(short_desc));
announce.token_acq.short_desc = short_desc;
LoadString(hResModule, IDS_TKMETHOD_LONG_DESC,
long_desc, ARRAYLENGTH(long_desc));
announce.token_acq.long_desc = long_desc;
if (KHM_FAILED(kmq_send_message(msg_type_afs,
AFS_MSG_ANNOUNCE, 0, &announce))) {
kmq_delete_subscription(announce.sub);
announce.sub = NULL;
return KHM_ERROR_UNKNOWN;
}
tk_method = announce.token_acq.method_id;
#ifdef USE_CONFIGURATION_PANELS
/* Register our configuration panels. */
/* Registering configuration panels is not required for
extension plug-in. As such, this bit of code is
commented out. However, if you wish to provide a
configuration panel, you should uncomment this block
and fill in the stub functions in config_main.c */
ZeroMemory(&creg, sizeof(creg));
short_desc[0] = L'\0';
LoadString(hResModule, IDS_CFG_SHORT_DESC,
short_desc, ARRAYLENGTH(short_desc));
long_desc[0] = L'\0';
LoadString(hResModule, IDS_CFG_LONG_DESC,
long_desc, ARRAYLENGTH(long_desc));
creg.name = CONFIGNODE_MAIN;
creg.short_desc = short_desc;
creg.long_desc = long_desc;
creg.h_module = hResModule;
creg.dlg_template = MAKEINTRESOURCE(IDD_CONFIG);
creg.dlg_proc = config_dlgproc;
creg.flags = 0;
khui_cfg_register(NULL, &creg);
#endif
}
break;
/* This is the last message that will be received by the
plugin. */
case KMSG_SYSTEM_EXIT:
{
khui_config_node cnode;
/* It should not be assumed that initialization of the
plugin went well at this point since we receive a
KMSG_SYSTEM_EXIT even if the initialization failed. */
/* Now unregister any configuration nodes we registered. */
if (KHM_SUCCEEDED(khui_cfg_open(NULL, CONFIGNODE_MAIN, &cnode))) {
khui_cfg_remove(cnode);
khui_cfg_release(cnode);
}
/* TODO: Perform additional uninitialization
operations. */
}
break;
}
return rv;
}
KHMEXP khm_int32 KHMAPI kmm_load_module(wchar_t * modname,
khm_int32 flags,
kmm_module * result)
{
kmm_module_i * m = NULL;
kmm_module_i * mi;
size_t cbsize;
khm_int32 rv = KHM_ERROR_SUCCESS;
if(FAILED(StringCbLength(modname, KMM_MAXCB_NAME, &cbsize)))
return KHM_ERROR_INVALID_PARAM;
cbsize += sizeof(wchar_t);
EnterCriticalSection(&cs_kmm);
mi = kmmint_find_module_i(modname);
if(mi != NULL) {
kmm_hold_module(kmm_handle_from_module(mi));
/* check if the module has either failed to load either or if
it has been terminated. If so, we try once again to load the
module. */
if(!(flags & KMM_LM_FLAG_NOLOAD) &&
(mi->state < 0 || mi->state == KMM_MODULE_STATE_EXITED))
{
mi->state = KMM_MODULE_STATE_PREINIT;
}
}
LeaveCriticalSection(&cs_kmm);
if(flags & KMM_LM_FLAG_NOLOAD) {
if(result)
*result = mi;
else if(mi)
kmm_release_module(kmm_handle_from_module(mi));
return (mi)? KHM_ERROR_SUCCESS: KHM_ERROR_NOT_FOUND;
}
if(mi) {
m = mi;
} else {
m = kmmint_get_module_i(modname);
m->state = KMM_MODULE_STATE_PREINIT;
kmm_hold_module(kmm_handle_from_module(m));
}
/* the module is already running or is already being
worked on by the registrar */
if(m->state != KMM_MODULE_STATE_PREINIT) {
if(result)
*result = kmm_handle_from_module(m);
else
kmm_release_module(kmm_handle_from_module(m));
return KHM_ERROR_EXISTS;
}
kmmint_add_to_module_queue();
if(flags & KMM_LM_FLAG_SYNC) {
kmm_hold_module(kmm_handle_from_module(m));
kmq_send_message(KMSG_KMM,
KMSG_KMM_I_REG,
KMM_REG_INIT_MODULE,
(void*) m);
if(m->state <= 0) {
/* failed to load ? */
if(m->state == KMM_MODULE_STATE_FAIL_NOT_FOUND)
rv = KHM_ERROR_NOT_FOUND;
else if(m->state == KMM_MODULE_STATE_FAIL_SIGNATURE)
rv = KHM_ERROR_INVALID_SIGNATURE;
else
rv = KHM_ERROR_UNKNOWN;
kmm_release_module(kmm_handle_from_module(m));
if(result)
*result = NULL;
} else {
if(result)
*result = kmm_handle_from_module(m);
else
kmm_release_module(kmm_handle_from_module(m));
}
} else {
kmm_hold_module(kmm_handle_from_module(m));
kmq_post_message(KMSG_KMM,
KMSG_KMM_I_REG,
KMM_REG_INIT_MODULE,
(void*) m);
if(result)
*result = kmm_handle_from_module(m);
else
kmm_release_module(kmm_handle_from_module(m));
}
return rv;
}
