static void
cfgui_create_window(khui_config_node node) {
assert(cfgui_hwnd == NULL);
khm_refresh_config();
DialogBoxParam(khm_hInstance,
MAKEINTRESOURCE(IDD_CFG_MAIN),
khm_hwnd_main,
cfgui_dlgproc,
(LPARAM) node);
}
static void
write_params_ident(ident_data * d) {
khm_handle csp_ident;
if (d->saved.monitor == d->work.monitor &&
d->saved.auto_renew == d->work.auto_renew &&
d->saved.sticky == d->work.sticky &&
!d->removed)
return;
if (KHM_FAILED(kcdb_identity_get_config(d->ident, KHM_PERM_WRITE,
&csp_ident))) {
#ifdef DEBUG
assert(FALSE);
#endif
return;
}
if (d->removed) {
khm_handle h = NULL;
khm_int32 flags = 0;
khc_remove_space(csp_ident);
/* calling kcdb_identity_get_config() will update the
KCDB_IDENT_FLAG_CONFIG flag for the identity to reflect the
fact that it nolonger has a configuration. */
kcdb_identity_get_config(d->ident, 0, &h);
if (h) {
/* what the ? */
#ifdef DEBUG
assert(FALSE);
#endif
khc_close_space(h);
}
#ifdef DEBUG
kcdb_identity_get_flags(d->ident, &flags);
assert(!(flags & KCDB_IDENT_FLAG_CONFIG));
#endif
} else {
if (d->saved.monitor != d->work.monitor)
khc_write_int32(csp_ident, L"Monitor", !!d->work.monitor);
if (d->saved.auto_renew != d->work.auto_renew)
khc_write_int32(csp_ident, L"AllowAutoRenew",
!!d->work.auto_renew);
if (d->saved.sticky != d->work.sticky) {
kcdb_identity_set_flags(d->ident,
(d->work.sticky)?KCDB_IDENT_FLAG_STICKY:0,
KCDB_IDENT_FLAG_STICKY);
}
}
khc_close_space(csp_ident);
d->saved = d->work;
d->applied = TRUE;
if (d->hwnd)
PostMessage(d->hwnd, KHUI_WM_CFG_NOTIFY,
MAKEWPARAM(0, WMCFG_UPDATE_STATE), 0);
khm_refresh_config();
}
/* dialog box procedure for the "Add new identity" dialog */
INT_PTR CALLBACK
khm_cfg_add_ident_proc(HWND hwnd,
UINT umsg,
WPARAM wParam,
LPARAM lParam) {
add_ident_data * d;
switch(umsg) {
case WM_INITDIALOG:
/* we create a new credentials blob and pull in the identity
selectors from the identity provider. */
d = PMALLOC(sizeof(*d));
ZeroMemory(d, sizeof(*d));
khui_cw_create_cred_blob(&d->nc);
#ifdef DEBUG
assert(d->nc != NULL);
#endif
if (d->nc == NULL) {
PFREE(d);
break;
}
if (KHM_FAILED(kcdb_identpro_get_ui_cb(&d->nc->ident_cb))) {
/* this should have worked. The only reason it would fail
is if there is no identity provider or if the identity
provider does not support providing idnetity
selectors. */
khui_cw_destroy_cred_blob(d->nc);
PFREE(d);
break;
}
#pragma warning(push)
#pragma warning(disable: 4244)
SetWindowLongPtr(hwnd, DWLP_USER, (LONG_PTR) d);
#pragma warning(pop)
/* get metrics for dynamic controls */
get_ctrl_row_metrics(&d->dim_small,
GetDlgItem(hwnd, IDC_SM_LBL),
GetDlgItem(hwnd, IDC_SM_CTL));
get_ctrl_row_metrics(&d->dim_medium,
GetDlgItem(hwnd, IDC_MED_LBL),
GetDlgItem(hwnd, IDC_MED_CTL));
get_ctrl_row_metrics(&d->dim_large,
GetDlgItem(hwnd, IDC_LG_LBL),
GetDlgItem(hwnd, IDC_LG_CTL));
{
RECT rlbl;
RECT rctl;
RECT rwnd;
GetWindowRect(GetDlgItem(hwnd, IDC_SM_LBL),
&rlbl);
GetWindowRect(GetDlgItem(hwnd, IDC_SM_CTL),
&rctl);
GetWindowRect(hwnd, &rwnd);
OffsetRect(&rlbl, -rwnd.left, -rwnd.top);
OffsetRect(&rctl, -rwnd.left, -rwnd.top);
d->current_x = rlbl.left;
d->current_y = rctl.top - GetSystemMetrics(SM_CYCAPTION);
GetWindowRect(GetDlgItem(hwnd, IDC_MED_CTL),
&rlbl);
OffsetRect(&rlbl, -rwnd.left, -rwnd.top);
d->row_gap = rlbl.top - rctl.bottom;
}
d->nc->hwnd = hwnd;
/* now call the UI callback and make it create the
controls. */
d->nc->ident_cb(d->nc, WMNC_IDENT_INIT, NULL, 0, 0,
(LPARAM) hwnd);
break;
case WM_DESTROY:
d = (add_ident_data *)(LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
if (d == NULL)
break;
d->nc->ident_cb(d->nc, WMNC_IDENT_EXIT, NULL, 0, 0, 0);
khui_cw_destroy_cred_blob(d->nc);
PFREE(d);
break;
case KHUI_WM_NC_NOTIFY:
d = (add_ident_data *)(LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
switch(HIWORD(wParam)) {
case WMNC_ADD_CONTROL_ROW:
{
khui_control_row * row;
RECT r_lbl, r_inp, r_enc;
struct ctrl_row_dimensions * dim;
HFONT hf;
row = (khui_control_row *) lParam;
#ifdef DEBUG
assert(row->label);
assert(row->input);
assert(d);
#endif
if (row->size == KHUI_CTRLSIZE_SMALL) {
dim = &d->dim_small;
} else if (row->size == KHUI_CTRLSIZE_HALF) {
dim = &d->dim_medium;
} else {
dim = &d->dim_large;
#ifdef DEBUG
assert(row->size == KHUI_CTRLSIZE_FULL);
#endif
}
CopyRect(&r_enc, &dim->enclosure);
CopyRect(&r_lbl, &dim->label);
CopyRect(&r_inp, &dim->control);
OffsetRect(&r_enc, d->current_x, d->current_y);
OffsetRect(&r_lbl, r_enc.left, r_enc.top);
OffsetRect(&r_inp, r_enc.left, r_enc.top);
d->current_y += r_enc.bottom - r_enc.top;
hf = (HFONT) SendDlgItemMessage(hwnd, IDOK, WM_GETFONT, 0, 0);
if (row->label) {
SetWindowPos(row->label,
((d->hwnd_last_ctrl != NULL)?
d->hwnd_last_ctrl :
HWND_TOP),
r_lbl.left, r_lbl.top,
r_lbl.right - r_lbl.left,
r_lbl.bottom - r_lbl.top,
SWP_DEFERERASE | SWP_NOACTIVATE |
SWP_NOOWNERZORDER);
if (hf)
SendMessage(row->label, WM_SETFONT,
(WPARAM) hf,
TRUE);
d->hwnd_last_ctrl = row->label;
}
if (row->input) {
SetWindowPos(row->input,
((d->hwnd_last_ctrl != NULL)?
d->hwnd_last_ctrl :
HWND_TOP),
r_inp.left, r_inp.top,
r_inp.right - r_inp.left,
r_inp.bottom - r_inp.top,
SWP_DEFERERASE | SWP_NOACTIVATE |
SWP_NOOWNERZORDER);
if (hf)
SendMessage(row->input, WM_SETFONT,
(WPARAM) hf,
TRUE);
d->hwnd_last_ctrl = row->input;
}
}
break;
case WMNC_IDENTITY_CHANGE:
break;
}
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK) {
wchar_t idname[KCDB_IDENT_MAXCCH_NAME];
wchar_t err_msg[1024];
khm_handle ident = NULL;
khm_handle csp_ident = NULL;
khm_size cb;
khm_int32 rv = KHM_ERROR_SUCCESS;
d = (add_ident_data *)(LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
if (!d || !d->nc)
break;
/* check if there was an identity selected */
if (d->nc->n_identities == 0 ||
d->nc->identities[0] == NULL) {
StringCbCopy(idname, sizeof(idname), L"");
LoadString(khm_hInstance, IDS_CFG_IDNAME_NON,
err_msg, ARRAYLENGTH(err_msg));
goto show_failure;
}
ident = d->nc->identities[0];
kcdb_identity_hold(ident);
cb = sizeof(idname);
kcdb_identity_get_name(ident, idname, &cb);
/* now we have to create the identity configuration. */
if (KHM_FAILED(rv = kcdb_identity_get_config(ident,
KHM_FLAG_CREATE,
&csp_ident))) {
wchar_t fmt[256];
LoadString(khm_hInstance, IDS_CFG_IDNAME_CCC,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(err_msg, sizeof(err_msg), fmt, rv);
kcdb_identity_release(ident);
goto show_failure;
}
/* create a value so that the configuration space will
actually be created in the registry. We don't want
this new identity to be sticky. */
khc_write_int32(csp_ident, L"Sticky", 0);
khm_refresh_config();
kcdb_identity_release(ident);
khc_close_space(csp_ident);
EndDialog(hwnd, 0);
break;
show_failure:
{
wchar_t title[512];
wchar_t fmt[256];
if (!err_msg[0])
break;
LoadString(khm_hInstance, IDS_CFG_IDNAME_PRB,
fmt, ARRAYLENGTH(fmt));
StringCbPrintf(title, sizeof(title), fmt, idname);
MessageBox(hwnd, err_msg, title, MB_OK | MB_ICONSTOP);
/* don't end the dialog yet */
break;
}
break;
} else if (LOWORD(wParam) == IDCANCEL) {
EndDialog(hwnd, 1);
} else {
d = (add_ident_data *)(LONG_PTR)
GetWindowLongPtr(hwnd, DWLP_USER);
if (d && d->nc && d->nc->ident_cb) {
return d->nc->ident_cb(d->nc, WMNC_IDENT_WMSG,
hwnd, umsg, wParam, lParam);
}
}
break;
}
return FALSE;
}
LRESULT CALLBACK
khm_main_wnd_proc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
LPNMHDR lpnm;
switch(uMsg) {
case WM_CREATE:
khm_create_main_window_controls(hwnd);
kmq_subscribe_hwnd(KMSG_CRED, hwnd);
kmq_subscribe_hwnd(KMSG_ACT, hwnd);
kmq_subscribe_hwnd(KMSG_KMM, hwnd);
mw_restart_refresh_timer(hwnd);
/* if the plug-ins finished loading before the window was
created, we would have missed the KMSG_KMM_I_DONE message.
So we check if the module load is complete and if so, fire
off KMSG_ACT_BEGIN_CMDLINE. */
if (!kmm_load_pending())
kmq_post_message(KMSG_ACT, KMSG_ACT_BEGIN_CMDLINE, 0, 0);
break;
case WM_DESTROY:
khm_pre_shutdown();
kmq_unsubscribe_hwnd(KMSG_ACT, hwnd);
kmq_unsubscribe_hwnd(KMSG_CRED, hwnd);
kmq_unsubscribe_hwnd(KMSG_KMM, hwnd);
HtmlHelp(NULL, NULL, HH_CLOSE_ALL, 0);
PostQuitMessage(0);
break;
case WM_NOTIFY:
lpnm = (LPNMHDR) lParam;
if(lpnm->hwndFrom == khui_main_menu_toolbar) {
return khm_menu_notify_main(lpnm);
} else if(lpnm->hwndFrom == khui_hwnd_standard_toolbar) {
return khm_toolbar_notify(lpnm);
} else if(lpnm->hwndFrom == khm_hwnd_rebar) {
return khm_rebar_notify(lpnm);
} else if(lpnm->hwndFrom == khm_hwnd_statusbar) {
return khm_statusbar_notify(lpnm);
}
break;
case WM_HELP:
khm_html_help(khm_hwnd_main, NULL, HH_HELP_CONTEXT, IDH_WELCOME);
break;
case WM_COMMAND:
switch(LOWORD(wParam)) {
/* general actions */
case KHUI_ACTION_VIEW_REFRESH:
khm_cred_refresh();
InvalidateRect(khm_hwnd_main_cred, NULL, FALSE);
return 0;
case KHUI_ACTION_PASSWD_ID:
if (khm_startup.processing)
return 0;
khm_cred_change_password(NULL);
return 0;
case KHUI_ACTION_NEW_CRED:
if (khm_startup.processing)
return 0;
khm_cred_obtain_new_creds(NULL);
return 0;
case KHUI_ACTION_RENEW_CRED:
if (khm_startup.processing)
return 0;
khm_cred_renew_creds();
return 0;
case KHUI_ACTION_DESTROY_CRED:
if (khm_startup.processing)
return 0;
khm_cred_destroy_creds(FALSE, FALSE);
return 0;
case KHUI_ACTION_SET_DEF_ID:
if (khm_startup.processing)
return 0;
khm_cred_set_default();
return 0;
case KHUI_ACTION_EXIT:
DestroyWindow(hwnd);
return 0;
case KHUI_ACTION_OPEN_APP:
khm_show_main_window();
return 0;
case KHUI_ACTION_CLOSE_APP:
khm_hide_main_window();
return 0;
case KHUI_ACTION_OPT_KHIM: {
khui_config_node node = NULL;
khui_cfg_open(NULL, L"KhmGeneral", &node);
khm_show_config_pane(node);
}
return 0;
case KHUI_ACTION_OPT_IDENTS: {
khui_config_node node = NULL;
khui_cfg_open(NULL, L"KhmIdentities", &node);
khm_show_config_pane(node);
}
return 0;
case KHUI_ACTION_OPT_APPEAR: {
khui_config_node node = NULL;
khui_cfg_open(NULL, L"KhmAppear", &node);
khm_show_config_pane(node);
}
return 0;
case KHUI_ACTION_OPT_NOTIF: {
khui_config_node node = NULL;
khui_cfg_open(NULL, L"KhmNotifications", &node);
khm_show_config_pane(node);
}
return 0;
case KHUI_ACTION_OPT_PLUGINS: {
khui_config_node node = NULL;
khui_cfg_open(NULL, L"KhmPlugins", &node);
khm_show_config_pane(node);
}
return 0;
case KHUI_ACTION_HELP_CTX:
khm_html_help(khm_hwnd_main, NULL, HH_HELP_CONTEXT, IDH_WELCOME);
return 0;
case KHUI_ACTION_HELP_CONTENTS:
khm_html_help(khm_hwnd_main, NULL, HH_DISPLAY_TOC, 0);
return 0;
case KHUI_ACTION_HELP_INDEX:
khm_html_help(khm_hwnd_main, NULL, HH_DISPLAY_INDEX, (DWORD_PTR) L"");
return 0;
case KHUI_ACTION_HELP_ABOUT:
khm_create_about_window();
return 0;
case KHUI_ACTION_IMPORT:
khm_cred_import();
return 0;
case KHUI_ACTION_PROPERTIES:
/* properties are not handled by the main window.
Just bounce it to credwnd. However, use SendMessage
instead of PostMessage so we don't lose context */
return SendMessage(khm_hwnd_main_cred, uMsg,
wParam, lParam);
case KHUI_ACTION_UICB:
khm_ui_cb(lParam);
return 0;
/* layout control */
case KHUI_ACTION_VIEW_ALL_IDS:
return SendMessage(khm_hwnd_main_cred, uMsg,
wParam, lParam);
case KHUI_ACTION_LAYOUT_MINI:
if (khm_main_wnd_mode == KHM_MAIN_WND_MINI) {
khm_set_main_window_mode(KHM_MAIN_WND_NORMAL);
} else {
khm_set_main_window_mode(KHM_MAIN_WND_MINI);
}
return SendMessage(khm_hwnd_main_cred, uMsg,
wParam, lParam);
case KHUI_ACTION_LAYOUT_RELOAD:
return SendMessage(khm_hwnd_main_cred, uMsg,
wParam, lParam);
case KHUI_ACTION_LAYOUT_ID:
case KHUI_ACTION_LAYOUT_TYPE:
case KHUI_ACTION_LAYOUT_LOC:
case KHUI_ACTION_LAYOUT_CUST:
khm_set_main_window_mode(KHM_MAIN_WND_NORMAL);
return SendMessage(khm_hwnd_main_cred, uMsg,
wParam, lParam);
/* menu commands */
case KHUI_PACTION_MENU:
if(HIWORD(lParam) == 1)
mm_last_hot_item = LOWORD(lParam);
return khm_menu_activate(MENU_ACTIVATE_DEFAULT);
case KHUI_PACTION_ESC:
/* if esc is pressed while no menu is active, we close the
main window */
if (mm_last_hot_item == -1) {
khm_close_main_window();
return 0;
}
/* generic, retargetting */
case KHUI_PACTION_UP:
case KHUI_PACTION_UP_TOGGLE:
case KHUI_PACTION_UP_EXTEND:
case KHUI_PACTION_PGUP:
case KHUI_PACTION_PGUP_EXTEND:
case KHUI_PACTION_DOWN:
case KHUI_PACTION_DOWN_TOGGLE:
case KHUI_PACTION_DOWN_EXTEND:
case KHUI_PACTION_PGDN:
case KHUI_PACTION_PGDN_EXTEND:
case KHUI_PACTION_LEFT:
case KHUI_PACTION_RIGHT:
case KHUI_PACTION_ENTER:
/* menu tracking */
if(mm_last_hot_item != -1) {
switch(LOWORD(wParam)) {
case KHUI_PACTION_LEFT:
khm_menu_activate(MENU_ACTIVATE_LEFT);
break;
case KHUI_PACTION_RIGHT:
khm_menu_activate(MENU_ACTIVATE_RIGHT);
break;
case KHUI_PACTION_ESC:
case KHUI_PACTION_ENTER:
khm_menu_activate(MENU_ACTIVATE_NONE);
break;
case KHUI_PACTION_DOWN:
khm_menu_track_current();
break;
}
return 0;
}
/*FALLTHROUGH*/
case KHUI_PACTION_DELETE:
case KHUI_PACTION_SELALL:
/* otherwise fallthrough and bounce to the creds window */
return SendMessage(khm_hwnd_main_cred, uMsg,
wParam, lParam);
default:
/* handle custom actions here */
{
khui_action * act;
/* check if this is an identity menu action. (custom
actions that were created for renewing or
destroying specific identities). */
if (khm_check_identity_menu_action(LOWORD(wParam)))
break;
act = khui_find_action(LOWORD(wParam));
if (act && act->listener) {
kmq_post_sub_msg(act->listener, KMSG_ACT, KMSG_ACT_ACTIVATE, act->cmd, NULL);
return 0;
}
}
}
break; /* WM_COMMAND */
case WM_SYSCOMMAND:
switch(wParam & 0xfff0) {
case SC_MINIMIZE:
khm_hide_main_window();
return 0;
case SC_CLOSE:
khm_close_main_window();
return 0;
}
break;
case WM_MEASUREITEM:
/* sent to measure the bitmaps associated with a menu item */
if(!wParam) /* sent by menu */
return khm_menu_measure_item(wParam, lParam);
break;
case WM_DRAWITEM:
/* sent to draw a menu item */
if(!wParam)
return khm_menu_draw_item(wParam, lParam);
break;
case WM_ERASEBKGND:
/* Don't erase the background. The whole client area is
covered with children. It doesn't need to be erased */
return TRUE;
break;
case WM_SIZE:
if(hwnd == khm_hwnd_main &&
(wParam == SIZE_MAXIMIZED || wParam == SIZE_RESTORED)) {
int cwidth, cheight;
RECT r_rebar, r_status;
cwidth = LOWORD(lParam);
cheight = HIWORD(lParam);
/* resize the rebar control */
SendMessage(khm_hwnd_rebar, WM_SIZE, 0, 0);
khm_update_statusbar(hwnd);
GetWindowRect(khm_hwnd_rebar, &r_rebar);
GetWindowRect(khm_hwnd_statusbar, &r_status);
/* the cred window fills the area between the rebar
and the status bar */
MoveWindow(khm_hwnd_main_cred, 0,
r_rebar.bottom - r_rebar.top,
r_status.right - r_status.left,
r_status.top - r_rebar.bottom, TRUE);
SetTimer(hwnd,
MW_RESIZE_TIMER,
MW_RESIZE_TIMEOUT,
NULL);
return 0;
}
break;
case WM_MOVE:
{
SetTimer(hwnd,
MW_RESIZE_TIMER,
MW_RESIZE_TIMEOUT,
NULL);
return 0;
}
break;
case WM_MOVING:
{
RECT * r;
r = (RECT *) lParam;
khm_adjust_window_dimensions_for_display(r,
KHM_DOCK_AUTO | KHM_DOCKF_XBORDER);
}
return TRUE;
case WM_TIMER:
if (wParam == MW_RESIZE_TIMER) {
main_wnd_save_sizepos();
return 0;
} else if (wParam == MW_REFRESH_TIMER) {
kmq_post_message(KMSG_CRED, KMSG_CRED_REFRESH, 0, 0);
return 0;
}
break;
case WM_MENUSELECT:
return khm_menu_handle_select(wParam, lParam);
case KMQ_WM_DISPATCH:
{
kmq_message * m;
khm_int32 rv = KHM_ERROR_SUCCESS;
kmq_wm_begin(lParam, &m);
if (m->type == KMSG_ACT &&
m->subtype == KMSG_ACT_REFRESH) {
khm_menu_refresh_items();
khm_update_standard_toolbar();
} else if (m->type == KMSG_ACT &&
m->subtype == KMSG_ACT_BEGIN_CMDLINE) {
khm_cred_begin_startup_actions();
} else if (m->type == KMSG_ACT &&
m->subtype == KMSG_ACT_CONTINUE_CMDLINE) {
khm_cred_process_startup_actions();
} else if (m->type == KMSG_ACT &&
m->subtype == KMSG_ACT_END_CMDLINE) {
/* nothing yet */
} else if (m->type == KMSG_ACT &&
m->subtype == KMSG_ACT_SYNC_CFG) {
khm_refresh_config();
} else if (m->type == KMSG_ACT &&
m->subtype == KMSG_ACT_ACTIVATE) {
/* some custom action fired */
khm_int32 action;
khui_action * paction;
action = m->uparam;
paction = khui_find_action(action);
if (paction && paction->data == (void *) CFGACTION_MAGIC) {
/* a custom configuration needs to be invoked */
khui_config_node node;
if (KHM_SUCCEEDED(khui_cfg_open(NULL, paction->name, &node))) {
khm_show_config_pane(node);
khui_cfg_release(node);
}
}
} else if (m->type == KMSG_CRED &&
m->subtype == KMSG_CRED_REFRESH) {
mw_restart_refresh_timer(hwnd);
} else if (m->type == KMSG_CRED &&
m->subtype == KMSG_CRED_ADDR_CHANGE) {
khm_cred_addr_change();
} else if (m->type == KMSG_CRED &&
m->subtype == KMSG_CRED_ROOTDELTA) {
khm_refresh_identity_menus();
} else if (m->type == KMSG_KMM &&
m->subtype == KMSG_KMM_I_DONE) {
kmq_post_message(KMSG_ACT, KMSG_ACT_BEGIN_CMDLINE, 0, 0);
}
return kmq_wm_end(m, rv);
}
case WM_KHUI_ASSIGN_COMMANDLINE_V1:
{
HANDLE hmap;
void * xfer;
wchar_t mapname[256];
khm_startup_options_v1 * pv1opt;
int code = KHM_ERROR_SUCCESS;
StringCbPrintf(mapname, sizeof(mapname),
COMMANDLINE_MAP_FMT, (DWORD) lParam);
hmap = OpenFileMapping(FILE_MAP_READ, FALSE, mapname);
if (hmap == NULL)
return 1;
xfer = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0,
sizeof(*pv1opt));
if (xfer) {
pv1opt = (khm_startup_options_v1 *) xfer;
khm_startup.init = pv1opt->init;
khm_startup.import = pv1opt->import;
khm_startup.renew = pv1opt->renew;
khm_startup.destroy = pv1opt->destroy;
khm_startup.autoinit = pv1opt->autoinit;
khm_startup.error_exit = FALSE;
khm_startup.no_main_window = FALSE;
khm_startup.remote_exit = FALSE;
khm_startup.display = 0;
UnmapViewOfFile(xfer);
} else {
code = KHM_ERROR_NOT_FOUND;
}
CloseHandle(hmap);
if(InSendMessage())
ReplyMessage(code);
if (code == KHM_ERROR_SUCCESS) {
khm_startup.exit = FALSE;
khm_startup.seen = FALSE;
khm_startup.remote = TRUE;
#ifdef DEBUG
assert(!khm_startup.processing);
#endif
khm_startup.processing = FALSE;
khm_cred_begin_startup_actions();
}
return code;
}
case WM_KHUI_ASSIGN_COMMANDLINE_V2:
{
HANDLE hmap;
void * xfer;
wchar_t mapname[256];
khm_startup_options_v2 *pv2opt = NULL;
khm_startup_options_v3 *pv3opt = NULL;
int code = KHM_ERROR_SUCCESS;
StringCbPrintf(mapname, sizeof(mapname),
COMMANDLINE_MAP_FMT, (DWORD) lParam);
hmap = OpenFileMapping(FILE_MAP_WRITE, FALSE, mapname);
if (hmap == NULL)
return 1;
xfer = MapViewOfFile(hmap, FILE_MAP_WRITE, 0, 0,
sizeof(*pv2opt));
if (xfer) {
pv2opt = (khm_startup_options_v2 *) xfer;
if (pv2opt->magic != STARTUP_OPTIONS_MAGIC ||
(pv2opt->cb_size != sizeof(*pv2opt) &&
pv2opt->cb_size != sizeof(*pv3opt))) {
code = KHM_ERROR_INVALID_PARAM;
goto done_with_v2_opt;
}
khm_startup.init = pv2opt->init;
khm_startup.import = pv2opt->import;
khm_startup.renew = pv2opt->renew;
khm_startup.destroy = pv2opt->destroy;
khm_startup.autoinit = pv2opt->autoinit;
khm_startup.exit = pv2opt->remote_exit;
pv2opt->code = KHM_ERROR_SUCCESS;
if (pv2opt->cb_size == sizeof(*pv3opt)) {
pv3opt = (khm_startup_options_v3 *) xfer;
khm_startup.display = pv3opt->remote_display;
} else {
khm_startup.display = 0;
}
done_with_v2_opt:
UnmapViewOfFile(xfer);
} else {
code = KHM_ERROR_NOT_FOUND;
}
CloseHandle(hmap);
if(InSendMessage())
ReplyMessage(code);
if (code == KHM_ERROR_SUCCESS) {
khm_startup.seen = FALSE;
khm_startup.remote = TRUE;
#ifdef DEBUG
assert(!khm_startup.processing);
#endif
khm_startup.processing = FALSE;
khm_cred_begin_startup_actions();
}
return code;
}
case WM_KHUI_QUERY_APP_VERSION:
{
HANDLE hmap;
void * xfer;
wchar_t mapname[256];
StringCbPrintf(mapname, sizeof(mapname),
QUERY_APP_VER_MAP_FMT, (DWORD) lParam);
hmap = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE,
FALSE, mapname);
if (hmap == NULL)
return 1;
xfer = MapViewOfFile(hmap, FILE_MAP_WRITE, 0, 0,
sizeof(khm_query_app_version));
if (xfer) {
khm_process_query_app_ver((khm_query_app_version *) xfer);
UnmapViewOfFile(xfer);
}
CloseHandle(hmap);
}
return 0;
}
return DefWindowProc(hwnd,uMsg,wParam,lParam);
}