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; } }