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_create_simple(const wchar_t * title,
const wchar_t * message,
khm_int32 severity,
khui_alert ** result)
{
khui_alert * a;
khui_alert_create_empty(&a);
khui_alert_set_title(a, title);
khui_alert_set_message(a, message);
khui_alert_set_severity(a, severity);
*result = a;
return KHM_ERROR_SUCCESS;
}
INT_PTR CALLBACK
khm_cfg_plugins_proc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam) {
plugin_dlg_data * d;
switch(uMsg) {
case WM_INITDIALOG:
{
kmm_plugin p;
kmm_plugin pn;
kmm_module m;
khm_size i;
LVCOLUMN lvc;
RECT r;
HWND hw;
wchar_t buf[256];
HIMAGELIST h_ilist;
HICON h_icon;
d = PMALLOC(sizeof(*d));
#ifdef DEBUG
assert(d);
#endif
ZeroMemory(d, sizeof(*d));
#pragma warning(push)
#pragma warning(disable: 4244)
SetWindowLongPtr(hwnd, DWLP_USER, (LONG_PTR) d);
#pragma warning(pop)
p = NULL;
i = 0;
do {
if (KHM_FAILED(kmm_get_next_plugin(p, &pn)))
break;
if (p)
kmm_release_plugin(p);
p = pn;
#ifdef DEBUG
assert(d->info[i] == NULL);
#endif
d->info[i] = PMALLOC(sizeof(*(d->info[i])));
#ifdef DEBUG
assert(d->info[i]);
#endif
ZeroMemory(&d->info[i]->plugin,
sizeof(d->info[i]->plugin));
if (KHM_FAILED(kmm_get_plugin_info_i(p, &d->info[i]->plugin))) {
PFREE(d->info[i]);
d->info[i] = NULL;
break;
}
ZeroMemory(&d->info[i]->module,
sizeof(d->info[i]->module));
if (KHM_SUCCEEDED(kmm_load_module(d->info[i]->plugin.reg.module,
KMM_LM_FLAG_NOLOAD,
&m))) {
kmm_get_module_info_i(m, &d->info[i]->module);
kmm_release_module(m);
}
i ++;
if (i == MAX_PLUGINS)
break;
} while(p);
if (p)
kmm_release_plugin(p);
d->n_info = i;
/* now populate the list view */
hw = GetDlgItem(hwnd, IDC_CFG_PLUGINS);
#ifdef DEBUG
assert(hw);
#endif
h_ilist = ImageList_Create(GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
ILC_COLOR8,
4, 4);
h_icon = LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDI_CFG_PLUGIN),
IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
LR_DEFAULTCOLOR);
#ifdef DEBUG
assert(h_icon);
#endif
ImageList_AddIcon(h_ilist, h_icon);
DestroyIcon(h_icon);
h_icon = LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDI_CFG_PLUGIN_DIS),
IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
LR_DEFAULTCOLOR);
#ifdef DEBUG
assert(h_icon);
#endif
ImageList_AddIcon(h_ilist, h_icon);
DestroyIcon(h_icon);
h_icon = LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDI_CFG_PLUGIN_ERR),
IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
LR_DEFAULTCOLOR);
#ifdef DEBUG
assert(h_icon);
#endif
ImageList_AddIcon(h_ilist, h_icon);
DestroyIcon(h_icon);
ListView_SetImageList(hw, h_ilist, LVSIL_STATE);
ZeroMemory(&lvc, sizeof(lvc));
lvc.mask = LVCF_TEXT | LVCF_WIDTH;
GetWindowRect(hw, &r);
lvc.cx = ((r.right - r.left) * 95) / 100;
lvc.pszText = buf;
LoadString(khm_hInstance, IDS_CFG_PI_COL_PLUGINS,
buf, ARRAYLENGTH(buf));
ListView_InsertColumn(hw, 0, &lvc);
for(i=0; i<d->n_info; i++) {
LVITEM lvi;
ZeroMemory(&lvi, sizeof(lvi));
lvi.mask = LVIF_PARAM | LVIF_TEXT | LVIF_STATE;
lvi.lParam = (LPARAM) d->info[i];
lvi.pszText = d->info[i]->plugin.reg.name;
if (d->info[i]->plugin.flags & KMM_PLUGIN_FLAG_DISABLED) {
lvi.state = INDEXTOSTATEIMAGEMASK(IDX_PLUGIN_DISABLED);
} else if (d->info[i]->plugin.state < 0) {
lvi.state = INDEXTOSTATEIMAGEMASK(IDX_PLUGIN_ERROR);
} else {
lvi.state = INDEXTOSTATEIMAGEMASK(IDX_PLUGIN_NORMAL);
}
ListView_InsertItem(hw, &lvi);
}
d->plugin_ico =
(HICON) LoadImage(khm_hInstance,
MAKEINTRESOURCE(IDI_CFG_PLUGIN),
IMAGE_ICON,
GetSystemMetrics(SM_CXICON),
GetSystemMetrics(SM_CYICON),
LR_DEFAULTCOLOR);
}
return FALSE;
case WM_NOTIFY:
{
LPNMHDR lpnm;
HWND hw;
d = (plugin_dlg_data *) (LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
if (d == NULL)
return FALSE;
if (wParam == IDC_CFG_PLUGINS &&
(lpnm = (LPNMHDR) lParam) &&
lpnm->code == LVN_ITEMCHANGED) {
LVITEM lvi;
hw = GetDlgItem(hwnd, IDC_CFG_PLUGINS);
#ifdef DEBUG
assert(hw);
#endif
if (ListView_GetSelectedCount(hw) != 1) {
SetDlgItemText(hwnd, IDC_CFG_DESC, L"");
SetDlgItemText(hwnd, IDC_CFG_STATE, L"");
SetDlgItemText(hwnd, IDC_CFG_MODULE, L"");
SetDlgItemText(hwnd, IDC_CFG_VENDOR, L"");
SetDlgItemText(hwnd, IDC_CFG_VERSION, L"");
EnableWindow(GetDlgItem(hwnd, IDC_CFG_ENABLE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_CFG_DISABLE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_CFG_UNREGISTER), FALSE);
SendDlgItemMessage(hwnd, IDC_CFG_DEPS,
LB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hwnd, IDC_CFG_ICON, STM_SETICON,
(WPARAM) d->plugin_ico, 0);
d->selected = NULL;
} else {
int idx;
plugin_data * info;
idx = ListView_GetNextItem(hw, -1, LVNI_SELECTED);
#ifdef DEBUG
assert(idx != -1);
#endif
ZeroMemory(&lvi, sizeof(lvi));
lvi.iItem = idx;
lvi.iSubItem = 0;
lvi.mask = LVIF_PARAM;
ListView_GetItem(hw, &lvi);
#ifdef DEBUG
assert(lvi.lParam != 0);
#endif
info = (plugin_data *) lvi.lParam;
update_dialog_fields(hwnd, d, info);
}
}
}
return TRUE;
case WM_COMMAND:
{
d = (plugin_dlg_data *) (LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
if (d == NULL)
return FALSE;
switch (wParam) {
case MAKEWPARAM(IDC_CFG_ENABLE, BN_CLICKED):
if (d->selected != NULL) {
khui_alert * alert = NULL;
wchar_t buf[KHUI_MAXCCH_MESSAGE];
wchar_t fmt[KHUI_MAXCCH_MESSAGE];
kmm_plugin p;
khui_alert_create_empty(&alert);
LoadString(khm_hInstance, IDS_CFG_P_ENBCNFT,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, d->selected->plugin.reg.name);
khui_alert_set_title(alert, buf);
LoadString(khm_hInstance, IDS_CFG_P_ENBCNFM,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, d->selected->plugin.reg.name);
khui_alert_set_message(alert, buf);
khui_alert_set_severity(alert, KHERR_INFO);
khui_alert_show_modal(alert);
kmm_enable_plugin(d->selected->plugin.h_plugin, TRUE);
khui_alert_release(alert);
p = d->selected->plugin.h_plugin;
kmm_hold_plugin(p);
kmm_release_plugin_info_i(&d->selected->plugin);
kmm_get_plugin_info_i(p, &d->selected->plugin);
kmm_release_plugin(p);
update_dialog_fields(hwnd, d, d->selected);
}
break;
case MAKEWPARAM(IDC_CFG_DISABLE, BN_CLICKED):
if (d->selected != NULL) {
khui_alert * alert = NULL;
wchar_t buf[KHUI_MAXCCH_MESSAGE];
wchar_t fmt[KHUI_MAXCCH_MESSAGE];
wchar_t depends[KHUI_MAXCCH_MESSAGE];
khm_size i;
kmm_plugin p;
khui_alert_create_empty(&alert);
#ifdef DEBUG
assert(alert);
#endif
if (alert == NULL)
break;
LoadString(khm_hInstance, IDS_CFG_P_DELCNFT,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, d->selected->plugin.reg.name);
khui_alert_set_title(alert, buf);
LoadString(khm_hInstance, IDS_CFG_P_DELCNFM,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, d->selected->plugin.reg.name);
khui_alert_set_message(alert, buf);
depends[0] = L'\0';
for (i=0; i<d->n_info; i++) {
wchar_t * t;
t = d->info[i]->plugin.reg.dependencies;
while(t) {
if (!wcscmp(t, d->selected->plugin.reg.name)) {
if (depends[0])
StringCbCat(depends, sizeof(depends), L", ");
StringCbCat(depends, sizeof(depends),
d->info[i]->plugin.reg.name);
break;
}
t = multi_string_next(t);
}
}
if (depends[0]) {
LoadString(khm_hInstance, IDS_CFG_P_DELCNFS,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, depends);
khui_alert_set_suggestion(alert, buf);
} else {
LoadString(khm_hInstance, IDS_CFG_P_DELNDEP,
buf, ARRAYLENGTH(buf));
khui_alert_set_suggestion(alert, buf);
}
khui_alert_add_command(alert, KHUI_PACTION_YES);
khui_alert_add_command(alert, KHUI_PACTION_NO);
khui_alert_set_severity(alert, KHERR_WARNING);
if (KHM_SUCCEEDED(khui_alert_show_modal(alert)) &&
alert->response == KHUI_PACTION_YES) {
kmm_enable_plugin(d->selected->plugin.h_plugin, FALSE);
}
khui_alert_release(alert);
p = d->selected->plugin.h_plugin;
kmm_hold_plugin(p);
kmm_release_plugin_info_i(&d->selected->plugin);
kmm_get_plugin_info_i(p, &d->selected->plugin);
kmm_release_plugin(p);
update_dialog_fields(hwnd, d, d->selected);
}
break;
case MAKEWPARAM(IDC_CFG_UNREGISTER, BN_CLICKED):
{
khui_alert * alert = NULL;
wchar_t buf[KHUI_MAXCCH_MESSAGE];
wchar_t fmt[KHUI_MAXCCH_MESSAGE];
wchar_t plist[KHUI_MAXCCH_MESSAGE];
khm_size i;
if (d->selected == NULL) {
#ifdef DEBUG
assert(FALSE);
#endif
break;
}
khui_alert_create_empty(&alert);
LoadString(khm_hInstance, IDS_CFG_P_UNRCNFT,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt,
d->selected->plugin.reg.name);
khui_alert_set_title(alert, buf);
LoadString(khm_hInstance, IDS_CFG_P_UNRCNFM,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt,
d->selected->plugin.reg.name);
khui_alert_set_message(alert, buf);
plist[0] = L'\0';
for (i=0; i < d->n_info; i++) {
if (!wcscmp(d->info[i]->module.reg.name,
d->selected->module.reg.name)) {
if (plist[0])
StringCbCat(plist, sizeof(plist), L", ");
StringCbCat(plist, sizeof(plist),
d->info[i]->plugin.reg.name);
}
}
#ifdef DEBUG
/* there should have been at least one plugin */
assert(plist[0]);
#endif
LoadString(khm_hInstance, IDS_CFG_P_UNRCNFS,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(buf, sizeof(buf), fmt, plist);
khui_alert_set_suggestion(alert, buf);
khui_alert_add_command(alert, KHUI_PACTION_YES);
khui_alert_add_command(alert, KHUI_PACTION_NO);
khui_alert_set_severity(alert, KHERR_WARNING);
if (KHM_SUCCEEDED(khui_alert_show_modal(alert)) &&
alert->response == KHUI_PACTION_YES) {
kmm_unregister_module(d->selected->module.reg.name, 0);
update_dialog_fields(hwnd, d, d->selected);
}
}
break;
case MAKEWPARAM(IDC_CFG_REGISTER, BN_CLICKED):
{
}
break;
}
}
return TRUE;
case WM_DESTROY:
{
khm_size i;
d = (plugin_dlg_data *) (LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
#ifdef DEBUG
assert(d);
#endif
if (d == NULL)
return TRUE;
for (i=0; i<d->n_info; i++) {
#ifdef DEBUG
assert(d->info[i]);
#endif
kmm_release_plugin_info_i(&d->info[i]->plugin);
kmm_release_module_info_i(&d->info[i]->module);
PFREE(d->info[i]);
}
PFREE(d);
SetWindowLongPtr(hwnd, DWLP_USER, 0);
khm_set_dialog_result(hwnd, 0);
}
return TRUE;
}
return FALSE;
}
/* Completion handler for KMSG_CRED messages. We control the overall
logic of credentials acquisition and other operations here. Once a
credentials operation is triggered, each successive message
completion notification will be used to dispatch the messages for
the next step in processing the operation. */
void KHMAPI
kmsg_cred_completion(kmq_message *m)
{
khui_new_creds * nc;
#ifdef DEBUG
assert(m->type == KMSG_CRED);
#else
if(m->type != KMSG_CRED)
return; /* huh? */
#endif
switch(m->subtype) {
case KMSG_CRED_PASSWORD:
/* fallthrough */
case KMSG_CRED_NEW_CREDS:
/* Cred types have attached themselves. Trigger the next
phase. */
kmq_post_message(KMSG_CRED, KMSG_CRED_DIALOG_SETUP, 0,
m->vparam);
break;
case KMSG_CRED_RENEW_CREDS:
nc = (khui_new_creds *) m->vparam;
/* khm_cred_dispatch_process_message() deals with the case
where there are no credential types that wants to
participate in this operation. */
khm_cred_dispatch_process_message(nc);
break;
case KMSG_CRED_DIALOG_SETUP:
nc = (khui_new_creds *) m->vparam;
khm_prep_newcredwnd(nc->hwnd);
/* all the controls have been created. Now initialize them */
if (nc->n_types > 0) {
kmq_post_subs_msg(nc->type_subs,
nc->n_types,
KMSG_CRED,
KMSG_CRED_DIALOG_PRESTART,
0,
m->vparam);
} else {
PostMessage(nc->hwnd, KHUI_WM_NC_NOTIFY,
MAKEWPARAM(0, WMNC_DIALOG_PROCESS_COMPLETE), 0);
}
break;
case KMSG_CRED_DIALOG_PRESTART:
/* all prestart stuff is done. Now to activate the dialog */
nc = (khui_new_creds *) m->vparam;
khm_show_newcredwnd(nc->hwnd);
kmq_post_subs_msg(nc->type_subs,
nc->n_types,
KMSG_CRED,
KMSG_CRED_DIALOG_START,
0,
m->vparam);
/* at this point, the dialog window takes over. We let it run
the show until KMSG_CRED_DIALOG_END is posted by the dialog
procedure. */
break;
case KMSG_CRED_PROCESS:
/* a wave of these messages have completed. We should check
if there's more */
nc = (khui_new_creds *) m->vparam;
/* if we are done processing all the plug-ins, then check if
there were any errors reported. Otherwise we dispatch
another set of messages. */
if(!khm_cred_dispatch_process_level(nc)) {
if(kherr_is_error()) {
khui_alert * alert;
kherr_event * evt;
kherr_context * ctx;
wchar_t ws_tfmt[512];
wchar_t w_idname[KCDB_IDENT_MAXCCH_NAME];
wchar_t ws_title[ARRAYLENGTH(ws_tfmt) + KCDB_IDENT_MAXCCH_NAME];
khm_size cb;
/* For renewals, we suppress the error message for the
following case:
- The renewal was for an identity
- There are no identity credentials for the
identity (no credentials that have the same type
as the identity provider). */
if (nc->subtype == KMSG_CRED_RENEW_CREDS &&
nc->ctx.scope == KHUI_SCOPE_IDENT &&
nc->ctx.identity != NULL) {
khm_handle tcs = NULL; /* credential set */
khm_size count = 0;
khm_int32 id_ctype = KCDB_CREDTYPE_INVALID;
khm_int32 delta = 0;
kcdb_identity_get_type(&id_ctype);
kcdb_credset_create(&tcs);
kcdb_credset_collect(tcs, NULL,
nc->ctx.identity,
id_ctype,
&delta);
kcdb_credset_get_size(tcs, &count);
kcdb_credset_delete(tcs);
if (count == 0) {
goto done_with_op;
}
}
ctx = kherr_peek_context();
evt = kherr_get_err_event(ctx);
kherr_evaluate_event(evt);
khui_alert_create_empty(&alert);
if (nc->subtype == KMSG_CRED_NEW_CREDS) {
khui_alert_set_type(alert, KHUI_ALERTTYPE_ACQUIREFAIL);
cb = sizeof(w_idname);
if (nc->n_identities == 0 ||
KHM_FAILED(kcdb_identity_get_name(nc->identities[0],
w_idname, &cb))) {
/* an identity could not be determined */
LoadString(khm_hInstance, IDS_NC_FAILED_TITLE,
ws_title, ARRAYLENGTH(ws_title));
} else {
LoadString(khm_hInstance, IDS_NC_FAILED_TITLE_I,
ws_tfmt, ARRAYLENGTH(ws_tfmt));
StringCbPrintf(ws_title, sizeof(ws_title),
ws_tfmt, w_idname);
khui_alert_set_ctx(alert,
KHUI_SCOPE_IDENT,
nc->identities[0],
KCDB_CREDTYPE_INVALID,
NULL);
}
} else if (nc->subtype == KMSG_CRED_PASSWORD) {
khui_alert_set_type(alert, KHUI_ALERTTYPE_CHPW);
cb = sizeof(w_idname);
if (nc->n_identities == 0 ||
KHM_FAILED(kcdb_identity_get_name(nc->identities[0],
w_idname, &cb))) {
LoadString(khm_hInstance, IDS_NC_PWD_FAILED_TITLE,
ws_title, ARRAYLENGTH(ws_title));
} else {
LoadString(khm_hInstance, IDS_NC_PWD_FAILED_TITLE_I,
ws_tfmt, ARRAYLENGTH(ws_tfmt));
StringCbPrintf(ws_title, sizeof(ws_title),
ws_tfmt, w_idname);
khui_alert_set_ctx(alert,
KHUI_SCOPE_IDENT,
nc->identities[0],
KCDB_CREDTYPE_INVALID,
NULL);
}
} else if (nc->subtype == KMSG_CRED_RENEW_CREDS) {
khui_alert_set_type(alert, KHUI_ALERTTYPE_RENEWFAIL);
cb = sizeof(w_idname);
if (nc->ctx.identity == NULL ||
KHM_FAILED(kcdb_identity_get_name(nc->ctx.identity,
w_idname, &cb))) {
LoadString(khm_hInstance, IDS_NC_REN_FAILED_TITLE,
ws_title, ARRAYLENGTH(ws_title));
} else {
LoadString(khm_hInstance, IDS_NC_REN_FAILED_TITLE_I,
ws_tfmt, ARRAYLENGTH(ws_tfmt));
StringCbPrintf(ws_title, sizeof(ws_title),
ws_tfmt, w_idname);
khui_alert_set_ctx(alert,
KHUI_SCOPE_IDENT,
nc->ctx.identity,
KCDB_CREDTYPE_INVALID,
NULL);
}
} else {
#ifdef DEBUG
assert(FALSE);
#endif
}
khui_alert_set_title(alert, ws_title);
khui_alert_set_severity(alert, evt->severity);
if(!evt->long_desc)
khui_alert_set_message(alert, evt->short_desc);
else
khui_alert_set_message(alert, evt->long_desc);
if(evt->suggestion)
khui_alert_set_suggestion(alert, evt->suggestion);
if (nc->subtype == KMSG_CRED_RENEW_CREDS &&
nc->ctx.identity != NULL) {
khm_int32 n_cmd;
n_cmd = khm_get_identity_new_creds_action(nc->ctx.identity);
if (n_cmd != 0) {
khui_alert_add_command(alert, n_cmd);
khui_alert_add_command(alert, KHUI_PACTION_CLOSE);
khui_alert_set_flags(alert, KHUI_ALERT_FLAG_DISPATCH_CMD,
KHUI_ALERT_FLAG_DISPATCH_CMD);
}
}
khui_alert_show(alert);
khui_alert_release(alert);
kherr_release_context(ctx);
kherr_clear_error();
}
done_with_op:
if (nc->subtype == KMSG_CRED_RENEW_CREDS) {
kmq_post_message(KMSG_CRED, KMSG_CRED_END, 0,
m->vparam);
} else {
PostMessage(nc->hwnd, KHUI_WM_NC_NOTIFY,
MAKEWPARAM(0, WMNC_DIALOG_PROCESS_COMPLETE),
0);
}
}
break;
case KMSG_CRED_END:
/* all is done. */
{
khui_new_creds * nc;
khm_boolean continue_cmdline = TRUE;
nc = (khui_new_creds *) m->vparam;
if (nc->subtype == KMSG_CRED_NEW_CREDS ||
nc->subtype == KMSG_CRED_PASSWORD) {
khm_cred_end_dialog(nc);
} else if (nc->subtype == KMSG_CRED_RENEW_CREDS) {
/* if this is a renewal that was triggered while we
were processing the commandline, then we need to
update the pending renewal count. */
if (khm_startup.processing) {
LONG renewals;
renewals = InterlockedDecrement(&khm_startup.pending_renewals);
if (renewals != 0) {
continue_cmdline = FALSE;
}
}
}
khui_cw_destroy_cred_blob(nc);
kmq_post_message(KMSG_CRED, KMSG_CRED_REFRESH, 0, 0);
if (continue_cmdline)
kmq_post_message(KMSG_ACT, KMSG_ACT_CONTINUE_CMDLINE, 0, 0);
}
break;
/* property sheet stuff */
case KMSG_CRED_PP_BEGIN:
/* all the pages should have been added by now. Just send out
the precreate message */
kmq_post_message(KMSG_CRED, KMSG_CRED_PP_PRECREATE, 0,
m->vparam);
break;
case KMSG_CRED_PP_END:
kmq_post_message(KMSG_CRED, KMSG_CRED_PP_DESTROY, 0,
m->vparam);
break;
case KMSG_CRED_DESTROY_CREDS:
#ifdef DEBUG
assert(m->vparam != NULL);
#endif
khui_context_release((khui_action_context *) m->vparam);
PFREE(m->vparam);
kmq_post_message(KMSG_CRED, KMSG_CRED_REFRESH, 0, 0);
kmq_post_message(KMSG_ACT, KMSG_ACT_CONTINUE_CMDLINE, 0, 0);
break;
case KMSG_CRED_IMPORT:
{
khm_boolean continue_cmdline = FALSE;
LONG pending_renewals;
/* once an import operation ends, we have to trigger a
renewal so that other plug-ins that didn't participate
in the import operation can have a chance at getting
the necessary credentials.
If we are in the middle of processing the commandline,
we have to be a little bit careful. We can't issue a
commandline conituation message right now because the
import action is still ongoing (since the renewals are
part of the action). Once the renewals have completed,
the completion handler will automatically issue a
commandline continuation message. However, if there
were no identities to renew, then we have to issue the
message ourselves.
*/
InterlockedIncrement(&khm_startup.pending_renewals);
khm_cred_renew_all_identities();
pending_renewals = InterlockedDecrement(&khm_startup.pending_renewals);
if (pending_renewals == 0 && khm_startup.processing)
kmq_post_message(KMSG_ACT, KMSG_ACT_CONTINUE_CMDLINE, 0, 0);
}
break;
case KMSG_CRED_REFRESH:
kcdb_identity_refresh_all();
break;
}
}