void kcdb_type_init(void)
{
kcdb_type type;
InitializeCriticalSection(&cs_type);
kcdb_type_namemap = hash_new_hashtable(
KCDB_TYPE_HASH_SIZE,
hash_string,
hash_string_comp,
kcdb_type_add_ref,
kcdb_type_del_ref);
kcdb_type_tbl = PMALLOC(sizeof(kcdb_type_i *) * (KCDB_TYPE_MAX_ID + 1));
ZeroMemory(kcdb_type_tbl, sizeof(kcdb_type_i *) * (KCDB_TYPE_MAX_ID + 1));
kcdb_types = NULL;
/* VOID */
ZeroMemory(&type, sizeof(type));
type.comp = kcdb_type_void_comp;
type.dup = kcdb_type_void_dup;
type.isValid = kcdb_type_void_isValid;
type.toString = kcdb_type_void_toString;
type.name = KCDB_TYPENAME_VOID;
type.id = KCDB_TYPE_VOID;
kcdb_type_register(&type, NULL);
/* String */
ZeroMemory(&type, sizeof(type));
type.comp = kcdb_type_string_comp;
type.dup = kcdb_type_string_dup;
type.isValid = kcdb_type_string_isValid;
type.toString = kcdb_type_string_toString;
type.name = KCDB_TYPENAME_STRING;
type.id = KCDB_TYPE_STRING;
type.flags = KCDB_TYPE_FLAG_CB_AUTO;
kcdb_type_register(&type, NULL);
/* Date/Time */
ZeroMemory(&type, sizeof(type));
type.comp = kcdb_type_date_comp;
type.dup = kcdb_type_date_dup;
type.isValid = kcdb_type_date_isValid;
type.toString = kcdb_type_date_toString;
type.name = KCDB_TYPENAME_DATE;
type.id = KCDB_TYPE_DATE;
type.cb_max = sizeof(FILETIME);
type.cb_min = sizeof(FILETIME);
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
kcdb_type_register(&type, NULL);
/* Interval */
ZeroMemory(&type, sizeof(type));
type.comp = kcdb_type_interval_comp;
type.dup = kcdb_type_interval_dup;
type.isValid = kcdb_type_interval_isValid;
type.toString = kcdb_type_interval_toString;
type.name = KCDB_TYPENAME_INTERVAL;
type.id = KCDB_TYPE_INTERVAL;
type.cb_max = sizeof(FILETIME);
type.cb_min = sizeof(FILETIME);
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
kcdb_type_register(&type, NULL);
/* Int32 */
ZeroMemory(&type, sizeof(type));
type.comp = kcdb_type_int32_comp;
type.dup = kcdb_type_int32_dup;
type.isValid = kcdb_type_int32_isValid;
type.toString = kcdb_type_int32_toString;
type.name = KCDB_TYPENAME_INT32;
type.id = KCDB_TYPE_INT32;
type.cb_max = sizeof(khm_int32);
type.cb_min = sizeof(khm_int32);
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
kcdb_type_register(&type, NULL);
/* Int64 */
ZeroMemory(&type, sizeof(type));
type.comp = kcdb_type_int64_comp;
type.dup = kcdb_type_int64_dup;
type.isValid = kcdb_type_int64_isValid;
type.toString = kcdb_type_int64_toString;
type.name = KCDB_TYPENAME_INT64;
type.id = KCDB_TYPE_INT64;
type.cb_max = sizeof(__int64);
type.cb_min = sizeof(__int64);
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
kcdb_type_register(&type, NULL);
/* Data */
ZeroMemory(&type, sizeof(type));
type.comp = kcdb_type_data_comp;
type.dup = kcdb_type_data_dup;
type.isValid = kcdb_type_data_isValid;
type.toString = kcdb_type_data_toString;
type.name = KCDB_TYPENAME_DATA;
type.id = KCDB_TYPE_DATA;
kcdb_type_register(&type, NULL);
}
/* process KMSG_SYSTEM messages */
khm_int32 KHMAPI
afs_msg_system(khm_int32 msg_subtype,
khm_ui_4 uparam,
void * vparam)
{
khm_int32 rv = KHM_ERROR_UNKNOWN;
switch(msg_subtype) {
case KMSG_SYSTEM_INIT:
/* If we are building against an older SDK, we should try to
load newer APIs if it's available at run-time. */
#if KH_VERSION_API < 7
do {
khm_version libver;
khm_ui_4 apiver;
khm_get_lib_version(&libver, &apiver);
if (apiver < 7)
break;
hm_netidmgr = LoadLibrary(NIMDLLNAME);
if (hm_netidmgr == NULL)
break;
pkhui_action_lock = (void (KHMAPI *)(void))
GetProcAddress(hm_netidmgr, API_khui_action_lock);
pkhui_action_unlock = (void (KHMAPI *)(void))
GetProcAddress(hm_netidmgr, API_khui_action_unlock);
pkhui_refresh_actions = (void (KHMAPI *)(void))
GetProcAddress(hm_netidmgr, API_khui_refresh_actions);
pkhui_request_UI_callback = (khm_int32 (KHMAPI *)(khm_ui_callback, void *))
GetProcAddress(hm_netidmgr, API_khui_request_UI_callback);
} while (FALSE);
#endif
/* Add the icon now. On NIM v2.x, doing so after tokens were
reported may result in a deadlock as we try to switch to
the UI thread and the UI thread is blocked on a resource
request to this plug-in. */
afs_icon_set_state(AFSICON_SERVICE_STOPPED, NULL);
/* Perform critical registrations and data structure
initalization */
{
kcdb_credtype ct;
wchar_t buf[KCDB_MAXCCH_LONG_DESC];
size_t cbsize;
kcdb_attrib att;
khm_handle csp_afscred = NULL;
khm_int32 disable_afscreds = FALSE;
ZeroMemory(&ct, sizeof(ct));
/* first of all, register the AFS token credential type */
ct.id = KCDB_CREDTYPE_AUTO;
ct.name = AFS_CREDTYPE_NAME;
if(LoadString(hResModule,
IDS_AFS_SHORT_DESC,
buf,
ARRAYLENGTH(buf)) != 0) {
StringCbLength(buf, sizeof(buf), &cbsize);
cbsize += sizeof(wchar_t);
ct.short_desc = PMALLOC(cbsize);
StringCbCopy(ct.short_desc, cbsize, buf);
} else
ct.short_desc = NULL;
if(LoadString(hResModule,
IDS_AFS_LONG_DESC,
buf,
ARRAYLENGTH(buf)) != 0) {
StringCbLength(buf, sizeof(buf), &cbsize);
cbsize += sizeof(wchar_t);
ct.long_desc = PMALLOC(cbsize);
StringCbCopy(ct.long_desc, cbsize, buf);
} else
ct.long_desc = NULL;
ct.icon = LoadImage(hResModule,
MAKEINTRESOURCE(IDI_AFSTOKEN),
IMAGE_ICON,
0, 0, LR_DEFAULTSIZE);
kmq_create_subscription(afs_plugin_cb, &afs_sub);
ct.sub = afs_sub;
kcdb_credtype_register(&ct, &afs_credtype_id);
/* register the attribute types */
{
kcdb_type type;
ZeroMemory(&type, sizeof(type));
type.comp = afs_type_principal_comp;
type.dup = afs_type_principal_dup;
type.isValid = afs_type_principal_isValid;
type.toString = afs_type_principal_toString;
type.name = AFS_TYPENAME_PRINCIPAL;
type.id = KCDB_TYPE_INVALID;
type.cb_max = sizeof(struct ktc_principal);
type.cb_min = sizeof(struct ktc_principal);
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
if(KHM_FAILED(kcdb_type_register(&type,
&afs_type_principal)))
goto _exit_init;
}
{
kcdb_type type;
kcdb_type *ti32 = NULL;
kcdb_type_get_info(KCDB_TYPE_INT32, &ti32);
ZeroMemory(&type, sizeof(type));
type.comp = ti32->comp;
type.dup = ti32->dup;
type.isValid = ti32->isValid;
type.toString = afs_type_method_toString;
type.name = AFS_TYPENAME_METHOD;
type.id = KCDB_TYPE_INVALID;
type.cb_max = sizeof(khm_int32);
type.cb_min = sizeof(khm_int32);
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
if(KHM_FAILED(kcdb_type_register(&type,
&afs_type_method))) {
kcdb_type_release_info(ti32);
goto _exit_init;
}
kcdb_type_release_info(ti32);
}
/* now register the attributes */
{
wchar_t short_desc[KCDB_MAXCCH_SHORT_DESC];
ZeroMemory(&att, sizeof(att));
att.type = KCDB_TYPE_STRING;
att.name = AFS_ATTRNAME_CELL;
LoadString(hResModule,
IDS_ATTR_CELL_SHORT_DESC,
short_desc,
ARRAYLENGTH(short_desc));
att.short_desc = short_desc;
att.long_desc = NULL;
att.id = KCDB_ATTR_INVALID;
att.flags = KCDB_ATTR_FLAG_TRANSIENT;
if(KHM_FAILED(rv = kcdb_attrib_register(&att,
&afs_attr_cell)))
goto _exit_init;
}
{
wchar_t short_desc[KCDB_MAXCCH_SHORT_DESC];
ZeroMemory(&att, sizeof(att));
att.type = KCDB_TYPE_STRING;
att.name = AFS_ATTRNAME_REALM;
LoadString(hResModule,
IDS_ATTR_REALM_SHORT_DESC,
short_desc,
ARRAYLENGTH(short_desc));
att.short_desc = short_desc;
att.long_desc = NULL;
att.id = KCDB_ATTR_INVALID;
att.flags = KCDB_ATTR_FLAG_TRANSIENT;
if(KHM_FAILED(rv = kcdb_attrib_register(&att,
&afs_attr_realm)))
goto _exit_init;
}
{
wchar_t short_desc[KCDB_MAXCCH_SHORT_DESC];
ZeroMemory(&att, sizeof(att));
att.type = afs_type_method;
att.name = AFS_ATTRNAME_METHOD;
LoadString(hResModule,
IDS_ATTR_METHOD_SHORT_DESC,
short_desc,
ARRAYLENGTH(short_desc));
att.short_desc = short_desc;
att.long_desc = NULL;
att.id = KCDB_ATTR_INVALID;
att.flags = KCDB_ATTR_FLAG_TRANSIENT;
if(KHM_FAILED(rv = kcdb_attrib_register(&att,
&afs_attr_method)))
goto _exit_init;
}
{
wchar_t short_desc[KCDB_MAXCCH_SHORT_DESC];
ZeroMemory(&att, sizeof(att));
att.type = afs_type_principal;
att.name = AFS_ATTRNAME_CLIENT_PRINC;
LoadString(hResModule,
IDS_ATTR_CLIENT_PRINC_SHORT_DESC,
short_desc,
ARRAYLENGTH(short_desc));
att.short_desc = short_desc;
att.long_desc = NULL;
att.id = KCDB_ATTR_INVALID;
att.flags = KCDB_ATTR_FLAG_TRANSIENT;
if(KHM_FAILED(rv = kcdb_attrib_register(&att, &afs_attr_client_princ)))
goto _exit_init;
}
{
wchar_t short_desc[KCDB_MAXCCH_SHORT_DESC];
ZeroMemory(&att, sizeof(att));
att.type = afs_type_principal;
att.name = AFS_ATTRNAME_SERVER_PRINC;
LoadString(hResModule,
IDS_ATTR_SERVER_PRINC_SHORT_DESC,
short_desc, ARRAYLENGTH(short_desc));
att.short_desc = short_desc;
att.long_desc = NULL;
att.id = KCDB_ATTR_INVALID;
att.flags = KCDB_ATTR_FLAG_TRANSIENT;
if(KHM_FAILED(rv = kcdb_attrib_register(&att, &afs_attr_server_princ)))
goto _exit_init;
}
/* afs_credset is our stock credentials set that we
use for all our credset needs (instead of creating
a new one every time) */
if(KHM_FAILED(rv = kcdb_credset_create(&afs_credset)))
goto _exit_init;
if(KHM_FAILED(rv = kcdb_credtype_get_id(KRB5_CREDTYPE_NAME,
&krb5_credtype_id)))
goto _exit_init;
/* register the configuration nodes */
{
khui_config_node node_ident;
khui_config_node_reg reg;
wchar_t wshort_desc[KHUI_MAXCCH_SHORT_DESC];
wchar_t wlong_desc[KHUI_MAXCCH_LONG_DESC];
if (KHM_FAILED(rv = khui_cfg_open(NULL,
L"KhmIdentities",
&node_ident)))
goto _exit_init;
ZeroMemory(®, sizeof(reg));
reg.name = AFS_CONFIG_NODE_MAIN;
reg.short_desc = wshort_desc;
reg.long_desc = wlong_desc;
reg.h_module = hResModule;
reg.dlg_template = MAKEINTRESOURCE(IDD_CFG_AFS);
reg.dlg_proc = afs_cfg_main_proc;
reg.flags = 0;
LoadString(hResModule, IDS_CFG_MAIN_LONG,
wlong_desc, ARRAYLENGTH(wlong_desc));
LoadString(hResModule, IDS_CFG_MAIN_SHORT,
wshort_desc, ARRAYLENGTH(wshort_desc));
khui_cfg_register(NULL, ®);
ZeroMemory(®, sizeof(reg));
reg.name = AFS_CONFIG_NODE_IDS;
reg.short_desc = wshort_desc;
reg.long_desc = wshort_desc;
reg.h_module = hResModule;
reg.dlg_template = MAKEINTRESOURCE(IDD_CFG_IDS_TAB);
reg.dlg_proc = afs_cfg_ids_proc;
reg.flags = KHUI_CNFLAG_SUBPANEL;
LoadString(hResModule, IDS_CFG_IDS_TAB,
wshort_desc, ARRAYLENGTH(wshort_desc));
khui_cfg_register(node_ident, ®);
ZeroMemory(®, sizeof(reg));
reg.name = AFS_CONFIG_NODE_ID;
reg.short_desc = wshort_desc;
reg.long_desc = wshort_desc;
reg.h_module = hResModule;
reg.dlg_template = MAKEINTRESOURCE(IDD_CFG_ID_TAB);
reg.dlg_proc = afs_cfg_id_proc;
reg.flags = KHUI_CNFLAG_SUBPANEL | KHUI_CNFLAG_PLURAL;
LoadString(hResModule, IDS_CFG_ID_TAB,
wshort_desc, ARRAYLENGTH(wshort_desc));
khui_cfg_register(node_ident, ®);
}
/* and register the AFS message type */
rv = kmq_register_type(AFS_MSG_TYPENAME, &afs_msg_type_id);
if (KHM_SUCCEEDED(rv))
kmq_subscribe(afs_msg_type_id, afs_plugin_cb);
/* if the configuration is set to disable afscreds.exe,
then we look for the shortcut and remove it if
found. */
if (KHM_SUCCEEDED(kmm_get_plugin_config(AFS_PLUGIN_NAME,
0,
&csp_afscred))) {
wchar_t wpath[MAX_PATH];
khc_read_int32(csp_afscred, L"Disableafscreds",
&disable_afscreds);
if (disable_afscreds &&
afs_cfg_get_afscreds_shortcut(wpath)) {
DeleteFile(wpath);
}
khc_close_space(csp_afscred);
}
/* try to register the "AFS Help" menu item, if
possible */
{
khm_handle h_sub = NULL;
wchar_t short_desc[KHUI_MAXCCH_SHORT_DESC];
wchar_t long_desc[KHUI_MAXCCH_LONG_DESC];
#if KH_VERSION_API < 7
if (pkhui_action_lock == NULL ||
pkhui_action_unlock == NULL ||
pkhui_refresh_actions == NULL ||
pkhui_request_UI_callback == NULL)
goto no_custom_help;
#endif
kmq_create_subscription(afs_plugin_cb, &h_sub);
LoadString(hResModule, IDS_ACTION_AFS_HELP,
short_desc, ARRAYLENGTH(short_desc));
LoadString(hResModule, IDS_ACTION_AFS_HELP_TT,
long_desc, ARRAYLENGTH(long_desc));
action_id_afs_help = khui_action_create(NULL,
short_desc,
long_desc,
NULL,
KHUI_ACTIONTYPE_TRIGGER,
h_sub);
if (action_id_afs_help != 0) {
khm_size s;
khm_size i;
khui_menu_def * help_menu;
khm_boolean refresh = FALSE;
khui_action_lock();
help_menu = khui_find_menu(KHUI_MENU_HELP);
if (help_menu) {
s = khui_menu_get_size(help_menu);
for (i=0; i < s; i++) {
khui_action_ref * aref;
aref = khui_menu_get_action(help_menu, i);
if (aref && !(aref->flags & KHUI_ACTIONREF_PACTION) &&
aref->action == KHUI_ACTION_HELP_INDEX) {
khui_menu_insert_action(help_menu,
i + 1,
action_id_afs_help,
0);
refresh = TRUE;
break;
}
}
}
khui_action_unlock();
if (refresh)
khui_refresh_actions();
}
#if KH_VERSION_API < 7
no_custom_help:
;
#endif
}
_exit_init:
if(ct.short_desc)
PFREE(ct.short_desc);
if(ct.long_desc)
PFREE(ct.long_desc);
}
/* now that the critical stuff is done, we move on to the
non-critical stuff */
if(KHM_SUCCEEDED(rv)) {
initialized = TRUE;
/* obtain existing tokens */
afs_list_tokens();
}
/* define this so that if there are no TGT's, we don't
deadlock trying to open a new creds dialog from within the
new creds dialog. */
SetEnvironmentVariable(L"KERBEROSLOGIN_NEVER_PROMPT", L"1");
break;
/* end of KMSG_SYSTEM_INIT */
case KMSG_SYSTEM_EXIT:
afs_remove_icon();
/* Try to remove the AFS plug-in action from Help menu if it
was successfully registered. Also, delete the action. */
if (action_id_afs_help != 0) {
khui_menu_def * help_menu;
khm_boolean menu_changed = FALSE;
khui_action_lock();
help_menu = khui_find_menu(KHUI_MENU_HELP);
if (help_menu) {
khm_size s;
khm_size i;
s = khui_menu_get_size(help_menu);
for (i=0; i < s; i++) {
khui_action_ref * aref = khui_menu_get_action(help_menu, i);
if (aref && !(aref->flags & KHUI_ACTIONREF_PACTION) &&
aref->action == action_id_afs_help) {
khui_menu_remove_action(help_menu, i);
menu_changed = TRUE;
break;
}
}
}
khui_action_delete(action_id_afs_help);
khui_action_unlock();
if (menu_changed)
khui_refresh_actions();
action_id_afs_help = 0;
}
if (afs_msg_type_id != -1) {
kmq_unsubscribe(afs_msg_type_id, afs_plugin_cb);
kmq_unregister_type(afs_msg_type_id);
}
if(afs_credtype_id >= 0) {
kcdb_credtype_unregister(afs_credtype_id);
}
#if 0
if(afs_attr_client >= 0) {
kcdb_attrib_unregister(afs_attr_client);
}
#endif
if(afs_attr_cell >= 0) {
kcdb_attrib_unregister(afs_attr_cell);
}
if(afs_attr_realm >= 0) {
kcdb_attrib_unregister(afs_attr_realm);
}
if(afs_attr_method >= 0) {
kcdb_attrib_unregister(afs_attr_method);
}
if(afs_attr_client_princ >= 0) {
kcdb_attrib_unregister(afs_attr_client_princ);
}
if(afs_attr_server_princ >= 0) {
kcdb_attrib_unregister(afs_attr_server_princ);
}
if(afs_type_principal >= 0) {
kcdb_type_unregister(afs_type_principal);
}
if(afs_type_method >= 0) {
kcdb_type_unregister(afs_type_method);
}
initialized = FALSE;
if(afs_credset)
kcdb_credset_delete(afs_credset);
/* afs_sub doesn't need to be deleted. That is taken care
of when unregistering the afs cred type */
afs_sub = NULL;
#if KH_VERSION_API < 7
if (hm_netidmgr)
FreeLibrary(hm_netidmgr);
pkhui_action_lock = NULL;
pkhui_action_unlock = NULL;
pkhui_refresh_actions = NULL;
pkhui_request_UI_callback = NULL;
#endif
rv = KHM_ERROR_SUCCESS;
break;
/* end of KMSG_SYSTEM_EXIT */
}
return rv;
}
/* called by the NetIDMgr module manager */
KHMEXP_EXP khm_int32 KHMAPI init_module(kmm_module h_module) {
khm_int32 rv = KHM_ERROR_SUCCESS;
kmm_plugin_reg pi;
wchar_t buf[256];
h_khModule = h_module;
rv = kmm_set_locale_info(h_module, locales, n_locales);
if(KHM_SUCCEEDED(rv)) {
hResModule = kmm_get_resource_hmodule(h_module);
} else
goto _exit;
k5_commctl_version = khm_get_commctl_version(NULL);
/* register the plugin */
ZeroMemory(&pi, sizeof(pi));
pi.name = KRB5_PLUGIN_NAME;
pi.type = KHM_PITYPE_CRED;
pi.icon = LoadImage(hResModule, MAKEINTRESOURCE(IDI_PLUGIN),
IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR | LR_DEFAULTSIZE);
pi.flags = 0;
pi.msg_proc = k5_msg_callback;
pi.description = buf;
pi.dependencies = NULL;
LoadString(hResModule, IDS_PLUGIN_DESC,
buf, ARRAYLENGTH(buf));
kmm_provide_plugin(h_module, &pi);
ZeroMemory(&pi, sizeof(pi));
pi.name = KRB5_IDENTPRO_NAME;
pi.type = KHM_PITYPE_IDENT;
pi.icon = LoadImage(hResModule, MAKEINTRESOURCE(IDI_PLUGIN),
IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR | LR_DEFAULTSIZE);
pi.flags = 0;
pi.msg_proc = k5_ident_callback;
pi.description = buf;
pi.dependencies = KRB5_PLUGIN_NAME L"\0";
LoadString(hResModule, IDS_IDENTPRO_DESC,
buf, ARRAYLENGTH(buf));
kmm_provide_plugin(h_module, &pi);
if(KHM_FAILED(rv = init_imports()))
goto _exit;
if(KHM_FAILED(rv = init_error_funcs()))
goto _exit;
/* Register common data types */
if(KHM_FAILED(kcdb_type_get_id(TYPENAME_ENCTYPE, &type_id_enctype))) {
kcdb_type type;
kcdb_type *t32;
kcdb_type_get_info(KCDB_TYPE_INT32, &t32);
type.id = KCDB_TYPE_INVALID;
type.name = TYPENAME_ENCTYPE;
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
type.cb_max = t32->cb_max;
type.cb_min = t32->cb_min;
type.isValid = t32->isValid;
type.comp = t32->comp;
type.dup = t32->dup;
type.toString = enctype_toString;
rv = kcdb_type_register(&type, &type_id_enctype);
kcdb_type_release_info(t32);
if(KHM_FAILED(rv))
goto _exit;
type_regd_enctype = TRUE;
}
if(KHM_FAILED(kcdb_type_get_id(TYPENAME_ADDR_LIST, &type_id_addr_list))) {
kcdb_type type;
kcdb_type *tdata;
kcdb_type_get_info(KCDB_TYPE_DATA, &tdata);
type.id = KCDB_TYPE_INVALID;
type.name = TYPENAME_ADDR_LIST;
type.flags = KCDB_TYPE_FLAG_CB_MIN;
type.cb_min = 0;
type.cb_max = 0;
type.isValid = tdata->isValid;
type.comp = addr_list_comp;
type.dup = tdata->dup;
type.toString = addr_list_toString;
rv = kcdb_type_register(&type, &type_id_addr_list);
kcdb_type_release_info(tdata);
if(KHM_FAILED(rv))
goto _exit;
type_regd_addr_list = TRUE;
}
if(KHM_FAILED(kcdb_type_get_id(TYPENAME_KRB5_FLAGS, &type_id_krb5_flags))) {
kcdb_type type;
kcdb_type *t32;
kcdb_type_get_info(KCDB_TYPE_INT32, &t32);
type.id = KCDB_TYPE_INVALID;
type.name = TYPENAME_KRB5_FLAGS;
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
type.cb_max = t32->cb_max;
type.cb_min = t32->cb_min;
type.isValid = t32->isValid;
type.comp = t32->comp;
type.dup = t32->dup;
type.toString = krb5flags_toString;
rv = kcdb_type_register(&type, &type_id_krb5_flags);
kcdb_type_release_info(t32);
if(KHM_FAILED(rv))
goto _exit;
type_regd_krb5_flags = TRUE;
}
if (KHM_FAILED(kcdb_type_get_id(TYPENAME_KVNO, &type_id_kvno))) {
kcdb_type type;
kcdb_type *t32;
kcdb_type_get_info(KCDB_TYPE_INT32, &t32);
type.id = KCDB_TYPE_INVALID;
type.name = TYPENAME_KVNO;
type.flags = KCDB_TYPE_FLAG_CB_FIXED;
type.cb_max = t32->cb_max;
type.cb_min = t32->cb_min;
type.isValid = t32->isValid;
type.comp = t32->comp;
type.dup = t32->dup;
type.toString = kvno_toString;
rv = kcdb_type_register(&type, &type_id_kvno);
kcdb_type_release_info(t32);
if (KHM_FAILED(rv))
goto _exit;
type_regd_kvno = TRUE;
}
/* Register common attributes */
if(KHM_FAILED(kcdb_attrib_get_id(ATTRNAME_KEY_ENCTYPE, &attr_id_key_enctype))) {
kcdb_attrib attrib;
wchar_t sbuf[KCDB_MAXCCH_SHORT_DESC];
wchar_t lbuf[KCDB_MAXCCH_SHORT_DESC];
/* although we are loading a long descriptoin, it still fits
in the short descriptoin buffer */
ZeroMemory(&attrib, sizeof(attrib));
attrib.name = ATTRNAME_KEY_ENCTYPE;
attrib.id = KCDB_ATTR_INVALID;
attrib.type = type_id_enctype;
attrib.flags = KCDB_ATTR_FLAG_TRANSIENT;
LoadString(hResModule, IDS_KEY_ENCTYPE_SHORT_DESC, sbuf, ARRAYLENGTH(sbuf));
LoadString(hResModule, IDS_KEY_ENCTYPE_LONG_DESC, lbuf, ARRAYLENGTH(lbuf));
attrib.short_desc = sbuf;
attrib.long_desc = lbuf;
rv = kcdb_attrib_register(&attrib, &attr_id_key_enctype);
if(KHM_FAILED(rv))
goto _exit;
attr_regd_key_enctype = TRUE;
}
if(KHM_FAILED(kcdb_attrib_get_id(ATTRNAME_TKT_ENCTYPE, &attr_id_tkt_enctype))) {
kcdb_attrib attrib;
wchar_t sbuf[KCDB_MAXCCH_SHORT_DESC];
wchar_t lbuf[KCDB_MAXCCH_SHORT_DESC];
/* although we are loading a long descriptoin, it still fits
in the short descriptoin buffer */
ZeroMemory(&attrib, sizeof(attrib));
attrib.name = ATTRNAME_TKT_ENCTYPE;
attrib.id = KCDB_ATTR_INVALID;
attrib.type = type_id_enctype;
attrib.flags = KCDB_ATTR_FLAG_TRANSIENT;
LoadString(hResModule, IDS_TKT_ENCTYPE_SHORT_DESC, sbuf, ARRAYLENGTH(sbuf));
LoadString(hResModule, IDS_TKT_ENCTYPE_LONG_DESC, lbuf, ARRAYLENGTH(lbuf));
attrib.short_desc = sbuf;
attrib.long_desc = lbuf;
rv = kcdb_attrib_register(&attrib, &attr_id_tkt_enctype);
if(KHM_FAILED(rv))
goto _exit;
attr_regd_tkt_enctype = TRUE;
}
if(KHM_FAILED(kcdb_attrib_get_id(ATTRNAME_ADDR_LIST, &attr_id_addr_list))) {
kcdb_attrib attrib;
wchar_t sbuf[KCDB_MAXCCH_SHORT_DESC];
wchar_t lbuf[KCDB_MAXCCH_SHORT_DESC];
/* although we are loading a long descriptoin, it still fits
in the short descriptoin buffer */
ZeroMemory(&attrib, sizeof(attrib));
attrib.name = ATTRNAME_ADDR_LIST;
attrib.id = KCDB_ATTR_INVALID;
attrib.type = type_id_addr_list;
attrib.flags = KCDB_ATTR_FLAG_TRANSIENT;
LoadString(hResModule, IDS_ADDR_LIST_SHORT_DESC, sbuf, ARRAYLENGTH(sbuf));
LoadString(hResModule, IDS_ADDR_LIST_LONG_DESC, lbuf, ARRAYLENGTH(lbuf));
attrib.short_desc = sbuf;
attrib.long_desc = lbuf;
rv = kcdb_attrib_register(&attrib, &attr_id_addr_list);
if(KHM_FAILED(rv))
goto _exit;
attr_regd_addr_list = TRUE;
}
if(KHM_FAILED(kcdb_attrib_get_id(ATTRNAME_KRB5_FLAGS, &attr_id_krb5_flags))) {
kcdb_attrib attrib;
wchar_t sbuf[KCDB_MAXCCH_SHORT_DESC];
/* although we are loading a long descriptoin, it still fits
in the short descriptoin buffer */
ZeroMemory(&attrib, sizeof(attrib));
attrib.name = ATTRNAME_KRB5_FLAGS;
attrib.id = KCDB_ATTR_INVALID;
attrib.type = type_id_krb5_flags;
attrib.flags = KCDB_ATTR_FLAG_TRANSIENT;
LoadString(hResModule, IDS_KRB5_FLAGS_SHORT_DESC, sbuf, ARRAYLENGTH(sbuf));
attrib.short_desc = sbuf;
attrib.long_desc = NULL;
rv = kcdb_attrib_register(&attrib, &attr_id_krb5_flags);
if(KHM_FAILED(rv))
goto _exit;
attr_regd_krb5_flags = TRUE;
}
if(KHM_FAILED(kcdb_attrib_get_id(ATTRNAME_KRB5_CCNAME, &attr_id_krb5_ccname))) {
kcdb_attrib attrib;
wchar_t sbuf[KCDB_MAXCCH_SHORT_DESC];
wchar_t lbuf[KCDB_MAXCCH_SHORT_DESC];
/* although we are loading a long descriptoin, it still fits
in the short descriptoin buffer */
ZeroMemory(&attrib, sizeof(attrib));
attrib.name = ATTRNAME_KRB5_CCNAME;
attrib.id = KCDB_ATTR_INVALID;
attrib.type = KCDB_TYPE_STRING;
attrib.flags =
KCDB_ATTR_FLAG_PROPERTY |
KCDB_ATTR_FLAG_TRANSIENT;
LoadString(hResModule, IDS_KRB5_CCNAME_SHORT_DESC, sbuf, ARRAYLENGTH(sbuf));
LoadString(hResModule, IDS_KRB5_CCNAME_LONG_DESC, lbuf, ARRAYLENGTH(lbuf));
attrib.short_desc = sbuf;
attrib.long_desc = lbuf;
rv = kcdb_attrib_register(&attrib, &attr_id_krb5_ccname);
if(KHM_FAILED(rv))
goto _exit;
attr_regd_krb5_ccname = TRUE;
}
if (KHM_FAILED(kcdb_attrib_get_id(ATTRNAME_KVNO, &attr_id_kvno))) {
kcdb_attrib attrib;
wchar_t sbuf[KCDB_MAXCCH_SHORT_DESC];
wchar_t lbuf[KCDB_MAXCCH_LONG_DESC];
/* although we are loading a long description, it still fits
in the short description buffer */
ZeroMemory(&attrib, sizeof(attrib));
attrib.name = ATTRNAME_KVNO;
attrib.id = KCDB_ATTR_INVALID;
attrib.type = type_id_kvno;
attrib.flags = KCDB_ATTR_FLAG_TRANSIENT;
LoadString(hResModule, IDS_KVNO_SHORT_DESC, sbuf, ARRAYLENGTH(sbuf));
LoadString(hResModule, IDS_KVNO_LONG_DESC, lbuf, ARRAYLENGTH(lbuf));
attrib.short_desc = sbuf;
attrib.long_desc = lbuf;
rv = kcdb_attrib_register(&attrib, &attr_id_kvno);
if (KHM_FAILED(rv))
goto _exit;
attr_regd_kvno = TRUE;
}
if (KHM_FAILED(kcdb_attrib_get_id(ATTRNAME_KRB5_IDFLAGS, &attr_id_krb5_idflags))) {
kcdb_attrib attrib;
ZeroMemory(&attrib, sizeof(attrib));
attrib.name = ATTRNAME_KRB5_IDFLAGS;
attrib.id = KCDB_ATTR_INVALID;
attrib.type = KCDB_TYPE_INT32;
attrib.flags = KCDB_ATTR_FLAG_PROPERTY |
KCDB_ATTR_FLAG_HIDDEN;
/* we don't bother localizing these strings since the
attribute is hidden. The user will not see these
descriptions anyway. */
attrib.short_desc = L"Krb5 ID flags";
attrib.long_desc = L"Kerberos 5 Identity Flags";
rv = kcdb_attrib_register(&attrib, &attr_id_krb5_idflags);
if (KHM_FAILED(rv))
goto _exit;
attr_regd_krb5_idflags = TRUE;
}
rv = kmm_get_plugins_config(0, &csp_plugins);
if(KHM_FAILED(rv)) goto _exit;
rv = khc_load_schema(csp_plugins, schema_krbconfig);
if(KHM_FAILED(rv)) goto _exit;
rv = khc_open_space(csp_plugins, CSNAME_KRB5CRED, 0, &csp_krbcred);
if(KHM_FAILED(rv)) goto _exit;
rv = khc_open_space(csp_krbcred, CSNAME_PARAMS, 0, &csp_params);
if(KHM_FAILED(rv)) goto _exit;
_exit:
return rv;
}
