void
k4_id_read_params(k4_id_data * d) {
khm_handle ident = NULL;
khm_handle csp_ident = NULL;
khm_handle csp_idk4 = NULL;
khm_int32 flags = 0;
khm_int32 t;
khc_read_int32(csp_params, L"Krb4NewCreds", &d->gettix);
ident = khui_cfg_get_data(d->cfg.ctx_node);
if (ident == NULL) {
d->gettix = 0;
goto done;
}
kcdb_identity_get_flags(ident, &flags);
if (!(flags & KCDB_IDENT_FLAG_DEFAULT)) {
d->gettix = 0;
goto done;
}
d->is_default_ident = TRUE;
if (d->gettix == 0)
goto done;
if (KHM_FAILED(kcdb_identity_get_config(ident, 0, &csp_ident)))
goto done;
if (KHM_FAILED(khc_open_space(csp_ident, CSNAME_KRB4CRED,
0, &csp_idk4)))
goto close_config;
if (KHM_SUCCEEDED(khc_read_int32(csp_idk4, L"Krb4NewCreds", &t)) &&
!t)
d->gettix = 1;
close_config:
if (csp_ident)
khc_close_space(csp_ident);
if (csp_idk4)
khc_close_space(csp_idk4);
done:
if (ident)
kcdb_identity_release(ident);
return;
}
khm_boolean k4_should_identity_get_k4(khm_handle ident) {
khm_int32 idflags = 0;
khm_int32 t = TRUE;
khm_handle csp_ident = NULL;
khm_handle csp_k4 = NULL;
khm_boolean get_k4 = TRUE;
khm_boolean id_spec = FALSE;
if (KHM_FAILED(kcdb_identity_get_flags(ident, &idflags)))
return FALSE;
if (!(idflags & KCDB_IDENT_FLAG_DEFAULT)) {
/* we only support k4 for one identity, and that is the
default identity. If we are trying to get tickets for a
non-default identity, then we start off as disabled unless
there is no default identity. */
khm_handle defident = NULL;
if (KHM_SUCCEEDED(kcdb_identity_get_default(&defident))) {
kcdb_identity_release(defident);
return FALSE;
}
}
if (KHM_SUCCEEDED(kcdb_identity_get_config(ident, 0, &csp_ident))) {
if (KHM_SUCCEEDED(khc_open_space(csp_ident, CSNAME_KRB4CRED, 0,
&csp_k4))) {
khm_int32 t = 0;
if (KHM_SUCCEEDED(khc_read_int32(csp_k4, L"Krb4NewCreds", &t))) {
get_k4 = !!t;
id_spec = TRUE;
}
khc_close_space(csp_k4);
}
khc_close_space(csp_ident);
}
/* if there was a value specified for the identity, then that
takes precedence. */
if (id_spec || !get_k4)
return get_k4;
if (KHM_SUCCEEDED(khc_read_int32(csp_params, L"Krb4NewCreds", &t)) &&
!t)
return FALSE;
return TRUE;
}
khm_boolean
k4_id_write_params(HWND hwnd, k4_id_data * d) {
khm_handle ident = NULL;
khm_int32 flags = 0;
khm_handle csp_ident = NULL;
khm_handle csp_idk4 = NULL;
khm_int32 gettix = 0;
khm_boolean applied = FALSE;
ident = khui_cfg_get_data(d->cfg.ctx_node);
if (ident == NULL)
return FALSE;
kcdb_identity_get_flags(ident, &flags);
if (!(flags & KCDB_IDENT_FLAG_DEFAULT))
goto done_apply;
if (IsDlgButtonChecked(hwnd, IDC_CFG_GETTIX) == BST_CHECKED)
gettix = TRUE;
if (KHM_FAILED(kcdb_identity_get_config(ident, KHM_FLAG_CREATE,
&csp_ident)))
goto done_apply;
if (KHM_FAILED(khc_open_space(csp_ident, CSNAME_KRB4CRED,
KHM_FLAG_CREATE | KCONF_FLAG_WRITEIFMOD,
&csp_idk4)))
goto done_apply;
khc_write_int32(csp_idk4, L"Krb4NewCreds", gettix);
applied = TRUE;
done_apply:
if (ident)
kcdb_identity_release(ident);
if (csp_ident)
khc_close_space(csp_ident);
if (csp_idk4)
khc_close_space(csp_idk4);
return applied;
}
static void
refresh_identity_config_panels(void) {
khm_handle ident = NULL;
kcdb_enumeration e = NULL;
khui_config_node cfg_iter = NULL;
khui_config_node cfg_ids = NULL;
if (KHM_FAILED(khui_cfg_open(NULL, L"KhmIdentities", &cfg_ids)))
goto _cleanup;
if (KHM_FAILED(kcdb_identity_begin_enum(KCDB_IDENT_FLAG_CONFIG,
KCDB_IDENT_FLAG_CONFIG,
&e, NULL)))
goto _done_adding;
while (KHM_SUCCEEDED(kcdb_enum_next(e, &ident))) {
khui_config_node cfg_id;
wchar_t cfgname[KCDB_MAXCCH_NAME];
khm_size cb;
cb = sizeof(cfgname);
if (KHM_FAILED(kcdb_identity_get_short_name(ident, FALSE, cfgname, &cb)))
continue;
if (KHM_SUCCEEDED(khui_cfg_open(cfg_ids, cfgname, &cfg_id))) {
/* it's already there */
khui_cfg_release(cfg_id);
continue;
} else {
khui_config_node_reg reg;
wchar_t wshort[KHUI_MAXCCH_SHORT_DESC];
wchar_t wlong[KHUI_MAXCCH_LONG_DESC];
wchar_t wfmt[KHUI_MAXCCH_NAME];
wchar_t widname[KHUI_MAXCCH_SHORT_DESC];
khm_size cb;
ZeroMemory(®, sizeof(reg));
reg.name = cfgname;
reg.short_desc = wshort;
reg.long_desc = wlong;
reg.h_module = khm_hInstance;
reg.dlg_template = MAKEINTRESOURCE(IDD_CFG_IDENTITY);
reg.dlg_proc = khm_cfg_identity_proc;
reg.flags = 0;
cb = sizeof(widname);
kcdb_get_resource(ident, KCDB_RES_DISPLAYNAME, KCDB_RFS_SHORT,
NULL, NULL, widname, &cb);
LoadString(khm_hInstance, IDS_CFG_IDENTITY_SHORT,
wfmt, ARRAYLENGTH(wfmt));
StringCbPrintf(wshort, sizeof(wshort), wfmt, widname);
LoadString(khm_hInstance, IDS_CFG_IDENTITY_LONG,
wfmt, ARRAYLENGTH(wfmt));
StringCbPrintf(wlong, sizeof(wlong), wfmt, widname);
khui_cfg_register(cfg_ids, ®);
if (KHM_SUCCEEDED(khui_cfg_open(cfg_ids, cfgname, &cfg_id))) {
khui_cfg_set_data(cfg_id, ident);
kcdb_identity_hold(ident);
khui_cfg_release(cfg_id);
}
}
} /* while enumerating through e */
kcdb_enum_end(e);
_done_adding:
for (khui_cfg_get_first_child(cfg_ids, &cfg_iter);
cfg_iter;
khui_cfg_get_next_release(&cfg_iter)) {
khm_int32 flags = 0;
ident = khui_cfg_get_data(cfg_iter);
if (ident == NULL ||
KHM_FAILED(kcdb_identity_get_flags(ident, &flags)) ||
(flags & (KCDB_IDENT_FLAG_ACTIVE|
KCDB_IDENT_FLAG_CONFIG)) != (KCDB_IDENT_FLAG_ACTIVE |
KCDB_IDENT_FLAG_CONFIG)) {
/* this configuration node needs to be removed */
if (ident) /* undo the hold done above for for
configuration node data */
kcdb_identity_release(ident);
khui_cfg_set_data(cfg_iter, NULL);
khui_cfg_remove(cfg_iter);
}
}
_cleanup:
if (cfg_ids) {
khui_cfg_release(cfg_ids);
}
}
static void
init_idents_data(void) {
khm_int32 rv;
wchar_t * t;
wchar_t * widnames = NULL;
khm_size cb;
int n_tries = 0;
int i;
khm_handle csp_cw = NULL;
if (cfg_idents.valid)
return;
#ifdef DEBUG
assert(cfg_idents.idents == NULL);
assert(cfg_idents.n_idents == 0);
assert(cfg_idents.nc_idents == 0);
#endif
if (KHM_SUCCEEDED(khc_open_space(NULL, L"CredWindow", 0, &csp_cw))) {
khm_int32 t;
if (KHM_SUCCEEDED(khc_read_int32(csp_cw, L"DefaultMonitor", &t)))
cfg_idents.saved.monitor = !!t;
else
cfg_idents.saved.monitor = TRUE;
if (KHM_SUCCEEDED(khc_read_int32(csp_cw, L"DefaultAllowAutoRenew", &t)))
cfg_idents.saved.auto_renew = !!t;
else
cfg_idents.saved.auto_renew = TRUE;
if (KHM_SUCCEEDED(khc_read_int32(csp_cw, L"DefaultSticky", &t)))
cfg_idents.saved.sticky = !!t;
else
cfg_idents.saved.sticky = FALSE;
khc_close_space(csp_cw);
csp_cw = NULL;
} else {
cfg_idents.saved.monitor = TRUE;
cfg_idents.saved.auto_renew = TRUE;
cfg_idents.saved.sticky = FALSE;
}
cfg_idents.work = cfg_idents.saved;
cfg_idents.applied = FALSE;
do {
rv = kcdb_identity_enum(KCDB_IDENT_FLAG_CONFIG,
KCDB_IDENT_FLAG_CONFIG,
NULL,
&cb,
&cfg_idents.n_idents);
if (rv != KHM_ERROR_TOO_LONG ||
cfg_idents.n_idents == 0 ||
cb == 0)
break;
if (widnames)
PFREE(widnames);
widnames = PMALLOC(cb);
#ifdef DEBUG
assert(widnames);
#endif
rv = kcdb_identity_enum(KCDB_IDENT_FLAG_CONFIG,
KCDB_IDENT_FLAG_CONFIG,
widnames,
&cb,
&cfg_idents.n_idents);
n_tries++;
} while(KHM_FAILED(rv) &&
n_tries < 5);
if (KHM_FAILED(rv) ||
cfg_idents.n_idents == 0) {
cfg_idents.n_idents = 0;
goto _cleanup;
}
cfg_idents.idents = PMALLOC(sizeof(*cfg_idents.idents) *
cfg_idents.n_idents);
#ifdef DEBUG
assert(cfg_idents.idents);
#endif
ZeroMemory(cfg_idents.idents,
sizeof(*cfg_idents.idents) * cfg_idents.n_idents);
cfg_idents.nc_idents = cfg_idents.n_idents;
i = 0;
for (t = widnames; t && *t; t = multi_string_next(t)) {
khm_handle ident;
if (KHM_FAILED(kcdb_identity_create(t, 0, &ident))) {
cfg_idents.n_idents--;
continue;
}
StringCbLength(t, KCDB_IDENT_MAXCB_NAME, &cb);
cb += sizeof(wchar_t);
cfg_idents.idents[i].idname = PMALLOC(cb);
#ifdef DEBUG
assert(cfg_idents.idents[i].idname);
#endif
StringCbCopy(cfg_idents.idents[i].idname, cb, t);
cfg_idents.idents[i].ident = ident;
cfg_idents.idents[i].removed = FALSE;
kcdb_identity_get_flags(ident, &cfg_idents.idents[i].flags);
#ifdef DEBUG
assert(cfg_idents.idents[i].flags & KCDB_IDENT_FLAG_CONFIG);
#endif
read_params_ident(&cfg_idents.idents[i]);
i++;
/* leave identity held */
}
_cleanup:
cfg_idents.valid = TRUE;
if (widnames)
PFREE(widnames);
}
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();
}
static ident_data *
find_ident_by_node(khui_config_node node) {
khm_size cb;
wchar_t idname[KCDB_IDENT_MAXCCH_NAME];
int i;
khm_handle ident = NULL;
cb = sizeof(idname);
khui_cfg_get_name(node, idname, &cb);
for (i=0; i < (int)cfg_idents.n_idents; i++) {
if (!wcscmp(cfg_idents.idents[i].idname, idname))
break;
}
if (i < (int)cfg_idents.n_idents)
return &cfg_idents.idents[i];
/* there is no identity data for this configuration node. We try
to create it. */
if (KHM_FAILED(kcdb_identity_create(idname, 0, &ident)))
return NULL;
if (cfg_idents.n_idents >= cfg_idents.nc_idents) {
cfg_idents.nc_idents = UBOUNDSS(cfg_idents.n_idents + 1,
IDENTS_DATA_ALLOC_INCR,
IDENTS_DATA_ALLOC_INCR);
#ifdef DEBUG
assert(cfg_idents.nc_idents > cfg_idents.n_idents);
#endif
cfg_idents.idents = PREALLOC(cfg_idents.idents,
sizeof(*cfg_idents.idents) *
cfg_idents.nc_idents);
#ifdef DEBUG
assert(cfg_idents.idents);
#endif
ZeroMemory(&(cfg_idents.idents[cfg_idents.n_idents]),
sizeof(*cfg_idents.idents) *
(cfg_idents.nc_idents - cfg_idents.n_idents));
}
i = (int) cfg_idents.n_idents;
StringCbLength(idname, KCDB_IDENT_MAXCB_NAME, &cb);
cb += sizeof(wchar_t);
cfg_idents.idents[i].idname = PMALLOC(cb);
#ifdef DEBUG
assert(cfg_idents.idents[i].idname);
#endif
StringCbCopy(cfg_idents.idents[i].idname, cb, idname);
cfg_idents.idents[i].ident = ident;
cfg_idents.idents[i].removed = FALSE;
kcdb_identity_get_flags(ident, &cfg_idents.idents[i].flags);
#ifdef DEBUG
assert(cfg_idents.idents[i].flags & KCDB_IDENT_FLAG_CONFIG);
#endif
read_params_ident(&cfg_idents.idents[i]);
cfg_idents.n_idents++;
/* leave ident held. */
return &cfg_idents.idents[i];
}
void k4_handle_wmnc_notify(k4_dlg_data * d,
WPARAM wParam,
LPARAM lParam) {
switch(HIWORD(wParam)) {
case WMNC_UPDATE_CREDTEXT:
{
if (d->nct->credtext) {
PFREE(d->nct->credtext);
d->nct->credtext = NULL;
}
if (d->nc->n_identities > 0 &&
d->nc->identities[0]) {
khm_int32 flags = 0;
wchar_t idname[KCDB_IDENT_MAXCCH_NAME];
wchar_t * atsign;
wchar_t * realm;
khm_size cb;
kcdb_identity_get_flags(d->nc->identities[0], &flags);
if (!(flags & KCDB_IDENT_FLAG_VALID)) {
break;
}
cb = sizeof(idname);
kcdb_identity_get_name(d->nc->identities[0], idname,
&cb);
atsign = wcsrchr(idname, L'@');
if (atsign == NULL || !atsign[1])
break;
realm = ++atsign;
if (d->k4_enabled) {
wchar_t wmethod[128];
wchar_t wfmt[128];
wchar_t wct[512];
LoadString(hResModule, IDS_CT_TGTFOR,
wfmt, ARRAYLENGTH(wfmt));
if (d->method == K4_METHOD_AUTO)
LoadString(hResModule, IDS_METHOD_AUTO, wmethod,
ARRAYLENGTH(wmethod));
else if (d->method == K4_METHOD_PASSWORD)
LoadString(hResModule, IDS_METHOD_PWD, wmethod,
ARRAYLENGTH(wmethod));
else if (d->method == K4_METHOD_K524)
LoadString(hResModule, IDS_METHOD_K524, wmethod,
ARRAYLENGTH(wmethod));
else {
assert(FALSE);
}
StringCbPrintf(wct, sizeof(wct), wfmt, realm, wmethod);
StringCbLength(wct, sizeof(wct), &cb);
cb += sizeof(wchar_t);
d->nct->credtext = PMALLOC(cb);
StringCbCopy(d->nct->credtext, cb, wct);
} else {
wchar_t wct[256];
LoadString(hResModule, IDS_CT_DISABLED,
wct, ARRAYLENGTH(wct));
StringCbLength(wct, sizeof(wct), &cb);
cb += sizeof(wchar_t);
d->nct->credtext = PMALLOC(cb);
StringCbCopy(d->nct->credtext, cb, wct);
}
}
/* no identities were selected. it is not the
responsibility of krb4 to complain about this. */
}
break;
case WMNC_IDENTITY_CHANGE:
k4_read_identity_data(d);
k4_update_display(d, TRUE);
break;
case WMNC_CREDTEXT_LINK:
{
wchar_t wid[KHUI_MAXCCH_HTLINK_FIELD];
wchar_t * wids;
khui_htwnd_link * l;
l = (khui_htwnd_link *) lParam;
StringCchCopyN(wid, ARRAYLENGTH(wid), l->id, l->id_len);
wids = wcschr(wid, L':');
if (!wids)
break;
else
wids++;
if (!wcscmp(wids, L"Enable")) {
d->k4_enabled = TRUE;
k4_update_display(d, TRUE);
khui_cw_enable_type(d->nc, credtype_id_krb4, TRUE);
}
}
break;
}
}
