src/WINNT/afsd/afskfw.c

   1 /*
   2  * Copyright (c) 2003 SkyRope, LLC
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  * - Redistributions of source code must retain the above copyright notice,
   9  *   this list of conditions and the following disclaimer.
  10  * - Redistributions in binary form must reproduce the above copyright notice,
  11  *   this list of conditions and the following disclaimer in the documentation
  12  *   and/or other materials provided with the distribution.
  13  * - Neither the name of Skyrope, LLC nor the names of its contributors may be
  14  *   used to endorse or promote products derived from this software without
  15  *   specific prior written permission from Skyrope, LLC.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * Portions of this code are derived from portions of the MIT
  30  * Leash Ticket Manager and LoadFuncs utilities.  For these portions the
  31  * following copyright applies.
  32  *
  33  * Copyright (c) 2003,2004 by the Massachusetts Institute of Technology.
  34  * All rights reserved.
  35  *
  36  * Export of this software from the United States of America may
  37  *   require a specific license from the United States Government.
  38  *   It is the responsibility of any person or organization contemplating
  39  *   export to obtain such a license before exporting.
  40  *
  41  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  42  * distribute this software and its documentation for any purpose and
  43  * without fee is hereby granted, provided that the above copyright
  44  * notice appear in all copies and that both that copyright notice and
  45  * this permission notice appear in supporting documentation, and that
  46  * the name of M.I.T. not be used in advertising or publicity pertaining
  47  * to distribution of the software without specific, written prior
  48  * permission.  Furthermore if you modify this software you must label
  49  * your software as modified software and not distribute it in such a
  50  * fashion that it might be confused with the original M.I.T. software.
  51  * M.I.T. makes no representations about the suitability of
  52  * this software for any purpose.  It is provided "as is" without express
  53  * or implied warranty.
  54  *
  55  */
  56
  57
  58 #define USE_MS2MIT
  59 #define USE_KRB4
  60 #include "afskfw-int.h"
  61 #include "afskfw.h"
  62
  63 #include <osilog.h>
  64 #include <rxkad_prototypes.h>   /* for life_to_time */
  65
  66 /*
  67  * TIMING _____________________________________________________________________
  68  *
  69  */
  70
  71 #define cminREMIND_TEST      1    // test every minute for expired creds
  72 #define cminREMIND_WARN      15   // warn if creds expire in 15 minutes
  73 #define cminRENEW            20   // renew creds when there are 20 minutes remaining
  74 #define cminMINLIFE          30   // minimum life of Kerberos creds
  75
  76 #define c100ns1SECOND        (LONGLONG)10000000
  77 #define cmsec1SECOND         1000
  78 #define cmsec1MINUTE         60000
  79 #define csec1MINUTE          60
  80
  81 /* Function Pointer Declarations for Delayed Loading */
  82 // CCAPI
  83 DECL_FUNC_PTR(cc_initialize);
  84 DECL_FUNC_PTR(cc_shutdown);
  85 DECL_FUNC_PTR(cc_get_NC_info);
  86 DECL_FUNC_PTR(cc_free_NC_info);
  87
  88 // leash functions
  89 DECL_FUNC_PTR(Leash_get_default_lifetime);
  90 DECL_FUNC_PTR(Leash_get_default_forwardable);
  91 DECL_FUNC_PTR(Leash_get_default_renew_till);
  92 DECL_FUNC_PTR(Leash_get_default_noaddresses);
  93 DECL_FUNC_PTR(Leash_get_default_proxiable);
  94 DECL_FUNC_PTR(Leash_get_default_publicip);
  95 DECL_FUNC_PTR(Leash_get_default_use_krb4);
  96 DECL_FUNC_PTR(Leash_get_default_life_min);
  97 DECL_FUNC_PTR(Leash_get_default_life_max);
  98 DECL_FUNC_PTR(Leash_get_default_renew_min);
  99 DECL_FUNC_PTR(Leash_get_default_renew_max);
 100 DECL_FUNC_PTR(Leash_get_default_renewable);
 101
 102 // krb5 functions
 103 DECL_FUNC_PTR(krb5_change_password);
 104 DECL_FUNC_PTR(krb5_get_init_creds_opt_init);
 105 DECL_FUNC_PTR(krb5_get_init_creds_opt_set_tkt_life);
 106 DECL_FUNC_PTR(krb5_get_init_creds_opt_set_renew_life);
 107 DECL_FUNC_PTR(krb5_get_init_creds_opt_set_forwardable);
 108 DECL_FUNC_PTR(krb5_get_init_creds_opt_set_proxiable);
 109 DECL_FUNC_PTR(krb5_get_init_creds_opt_set_address_list);
 110 DECL_FUNC_PTR(krb5_get_init_creds_password);
 111 DECL_FUNC_PTR(krb5_build_principal_ext);
 112 DECL_FUNC_PTR(krb5_cc_get_name);
 113 DECL_FUNC_PTR(krb5_cc_resolve);
 114 DECL_FUNC_PTR(krb5_cc_default);
 115 DECL_FUNC_PTR(krb5_cc_default_name);
 116 DECL_FUNC_PTR(krb5_cc_set_default_name);
 117 DECL_FUNC_PTR(krb5_cc_initialize);
 118 DECL_FUNC_PTR(krb5_cc_destroy);
 119 DECL_FUNC_PTR(krb5_cc_close);
 120 DECL_FUNC_PTR(krb5_cc_store_cred);
 121 DECL_FUNC_PTR(krb5_cc_copy_creds);
 122 DECL_FUNC_PTR(krb5_cc_retrieve_cred);
 123 DECL_FUNC_PTR(krb5_cc_get_principal);
 124 DECL_FUNC_PTR(krb5_cc_start_seq_get);
 125 DECL_FUNC_PTR(krb5_cc_next_cred);
 126 DECL_FUNC_PTR(krb5_cc_end_seq_get);
 127 DECL_FUNC_PTR(krb5_cc_remove_cred);
 128 DECL_FUNC_PTR(krb5_cc_set_flags);
 129 DECL_FUNC_PTR(krb5_cc_get_type);
 130 DECL_FUNC_PTR(krb5_free_context);
 131 DECL_FUNC_PTR(krb5_free_cred_contents);
 132 DECL_FUNC_PTR(krb5_free_principal);
 133 DECL_FUNC_PTR(krb5_get_in_tkt_with_password);
 134 DECL_FUNC_PTR(krb5_init_context);
 135 DECL_FUNC_PTR(krb5_parse_name);
 136 DECL_FUNC_PTR(krb5_timeofday);
 137 DECL_FUNC_PTR(krb5_timestamp_to_sfstring);
 138 DECL_FUNC_PTR(krb5_unparse_name);
 139 DECL_FUNC_PTR(krb5_get_credentials);
 140 DECL_FUNC_PTR(krb5_mk_req);
 141 DECL_FUNC_PTR(krb5_sname_to_principal);
 142 DECL_FUNC_PTR(krb5_get_credentials_renew);
 143 DECL_FUNC_PTR(krb5_free_data);
 144 DECL_FUNC_PTR(krb5_free_data_contents);
 145 DECL_FUNC_PTR(krb5_free_unparsed_name);
 146 DECL_FUNC_PTR(krb5_os_localaddr);
 147 DECL_FUNC_PTR(krb5_copy_keyblock_contents);
 148 DECL_FUNC_PTR(krb5_copy_data);
 149 DECL_FUNC_PTR(krb5_free_creds);
 150 DECL_FUNC_PTR(krb5_build_principal);
 151 DECL_FUNC_PTR(krb5_get_renewed_creds);
 152 DECL_FUNC_PTR(krb5_get_default_config_files);
 153 DECL_FUNC_PTR(krb5_free_config_files);
 154 DECL_FUNC_PTR(krb5_get_default_realm);
 155 DECL_FUNC_PTR(krb5_free_ticket);
 156 DECL_FUNC_PTR(krb5_decode_ticket);
 157 DECL_FUNC_PTR(krb5_get_host_realm);
 158 DECL_FUNC_PTR(krb5_free_host_realm);
 159 DECL_FUNC_PTR(krb5_free_addresses);
 160 DECL_FUNC_PTR(krb5_c_random_make_octets);
 161
 162 // Krb524 functions
 163 DECL_FUNC_PTR(krb524_init_ets);
 164 DECL_FUNC_PTR(krb524_convert_creds_kdc);
 165
 166 // krb4 functions
 167 DECL_FUNC_PTR(krb_get_cred);
 168 DECL_FUNC_PTR(tkt_string);
 169 DECL_FUNC_PTR(krb_get_tf_realm);
 170 DECL_FUNC_PTR(krb_mk_req);
 171
 172 // ComErr functions
 173 DECL_FUNC_PTR(com_err);
 174 DECL_FUNC_PTR(error_message);
 175
 176 // Profile functions
 177 DECL_FUNC_PTR(profile_init);
 178 DECL_FUNC_PTR(profile_release);
 179 DECL_FUNC_PTR(profile_get_subsection_names);
 180 DECL_FUNC_PTR(profile_free_list);
 181 DECL_FUNC_PTR(profile_get_string);
 182 DECL_FUNC_PTR(profile_release_string);
 183
 184 // Service functions
 185 DECL_FUNC_PTR(OpenSCManagerA);
 186 DECL_FUNC_PTR(OpenServiceA);
 187 DECL_FUNC_PTR(QueryServiceStatus);
 188 DECL_FUNC_PTR(CloseServiceHandle);
 189 #ifdef USE_MS2MIT
 190 DECL_FUNC_PTR(LsaNtStatusToWinError);
 191 #endif /* USE_MS2MIT */
 192
 193 #ifdef USE_MS2MIT
 194 // LSA Functions
 195 DECL_FUNC_PTR(LsaConnectUntrusted);
 196 DECL_FUNC_PTR(LsaLookupAuthenticationPackage);
 197 DECL_FUNC_PTR(LsaCallAuthenticationPackage);
 198 DECL_FUNC_PTR(LsaFreeReturnBuffer);
 199 DECL_FUNC_PTR(LsaGetLogonSessionData);
 200 #endif /* USE_MS2MIT */
 201
 202 // CCAPI
 203 FUNC_INFO ccapi_fi[] = {
 204     MAKE_FUNC_INFO(cc_initialize),
 205     MAKE_FUNC_INFO(cc_shutdown),
 206     MAKE_FUNC_INFO(cc_get_NC_info),
 207     MAKE_FUNC_INFO(cc_free_NC_info),
 208     END_FUNC_INFO
 209 };
 210
 211 FUNC_INFO leash_fi[] = {
 212     MAKE_FUNC_INFO(Leash_get_default_lifetime),
 213     MAKE_FUNC_INFO(Leash_get_default_renew_till),
 214     MAKE_FUNC_INFO(Leash_get_default_forwardable),
 215     MAKE_FUNC_INFO(Leash_get_default_noaddresses),
 216     MAKE_FUNC_INFO(Leash_get_default_proxiable),
 217     MAKE_FUNC_INFO(Leash_get_default_publicip),
 218     MAKE_FUNC_INFO(Leash_get_default_use_krb4),
 219     MAKE_FUNC_INFO(Leash_get_default_life_min),
 220     MAKE_FUNC_INFO(Leash_get_default_life_max),
 221     MAKE_FUNC_INFO(Leash_get_default_renew_min),
 222     MAKE_FUNC_INFO(Leash_get_default_renew_max),
 223     MAKE_FUNC_INFO(Leash_get_default_renewable),
 224     END_FUNC_INFO
 225 };
 226
 227 FUNC_INFO k5_fi[] = {
 228     MAKE_FUNC_INFO(krb5_change_password),
 229     MAKE_FUNC_INFO(krb5_get_init_creds_opt_init),
 230     MAKE_FUNC_INFO(krb5_get_init_creds_opt_set_tkt_life),
 231     MAKE_FUNC_INFO(krb5_get_init_creds_opt_set_renew_life),
 232     MAKE_FUNC_INFO(krb5_get_init_creds_opt_set_forwardable),
 233     MAKE_FUNC_INFO(krb5_get_init_creds_opt_set_proxiable),
 234     MAKE_FUNC_INFO(krb5_get_init_creds_opt_set_address_list),
 235     MAKE_FUNC_INFO(krb5_get_init_creds_password),
 236     MAKE_FUNC_INFO(krb5_build_principal_ext),
 237     MAKE_FUNC_INFO(krb5_cc_get_name),
 238     MAKE_FUNC_INFO(krb5_cc_resolve),
 239     MAKE_FUNC_INFO(krb5_cc_default),
 240     MAKE_FUNC_INFO(krb5_cc_default_name),
 241     MAKE_FUNC_INFO(krb5_cc_set_default_name),
 242     MAKE_FUNC_INFO(krb5_cc_initialize),
 243     MAKE_FUNC_INFO(krb5_cc_destroy),
 244     MAKE_FUNC_INFO(krb5_cc_close),
 245     MAKE_FUNC_INFO(krb5_cc_copy_creds),
 246     MAKE_FUNC_INFO(krb5_cc_store_cred),
 247     MAKE_FUNC_INFO(krb5_cc_retrieve_cred),
 248     MAKE_FUNC_INFO(krb5_cc_get_principal),
 249     MAKE_FUNC_INFO(krb5_cc_start_seq_get),
 250     MAKE_FUNC_INFO(krb5_cc_next_cred),
 251     MAKE_FUNC_INFO(krb5_cc_end_seq_get),
 252     MAKE_FUNC_INFO(krb5_cc_remove_cred),
 253     MAKE_FUNC_INFO(krb5_cc_set_flags),
 254     MAKE_FUNC_INFO(krb5_cc_get_type),
 255     MAKE_FUNC_INFO(krb5_free_context),
 256     MAKE_FUNC_INFO(krb5_free_cred_contents),
 257     MAKE_FUNC_INFO(krb5_free_principal),
 258     MAKE_FUNC_INFO(krb5_get_in_tkt_with_password),
 259     MAKE_FUNC_INFO(krb5_init_context),
 260     MAKE_FUNC_INFO(krb5_parse_name),
 261     MAKE_FUNC_INFO(krb5_timeofday),
 262     MAKE_FUNC_INFO(krb5_timestamp_to_sfstring),
 263     MAKE_FUNC_INFO(krb5_unparse_name),
 264     MAKE_FUNC_INFO(krb5_get_credentials),
 265     MAKE_FUNC_INFO(krb5_mk_req),
 266     MAKE_FUNC_INFO(krb5_sname_to_principal),
 267     MAKE_FUNC_INFO(krb5_get_credentials_renew),
 268     MAKE_FUNC_INFO(krb5_free_data),
 269     MAKE_FUNC_INFO(krb5_free_data_contents),
 270     MAKE_FUNC_INFO(krb5_free_unparsed_name),
 271     MAKE_FUNC_INFO(krb5_os_localaddr),
 272     MAKE_FUNC_INFO(krb5_copy_keyblock_contents),
 273     MAKE_FUNC_INFO(krb5_copy_data),
 274     MAKE_FUNC_INFO(krb5_free_creds),
 275     MAKE_FUNC_INFO(krb5_build_principal),
 276     MAKE_FUNC_INFO(krb5_get_renewed_creds),
 277     MAKE_FUNC_INFO(krb5_free_addresses),
 278     MAKE_FUNC_INFO(krb5_get_default_config_files),
 279     MAKE_FUNC_INFO(krb5_free_config_files),
 280     MAKE_FUNC_INFO(krb5_get_default_realm),
 281     MAKE_FUNC_INFO(krb5_free_ticket),
 282     MAKE_FUNC_INFO(krb5_decode_ticket),
 283     MAKE_FUNC_INFO(krb5_get_host_realm),
 284     MAKE_FUNC_INFO(krb5_free_host_realm),
 285     MAKE_FUNC_INFO(krb5_free_addresses),
 286     MAKE_FUNC_INFO(krb5_c_random_make_octets),
 287     END_FUNC_INFO
 288 };
 289
 290 FUNC_INFO k4_fi[] = {
 291     MAKE_FUNC_INFO(krb_get_cred),
 292     MAKE_FUNC_INFO(krb_get_tf_realm),
 293     MAKE_FUNC_INFO(krb_mk_req),
 294     MAKE_FUNC_INFO(tkt_string),
 295     END_FUNC_INFO
 296 };
 297
 298 FUNC_INFO k524_fi[] = {
 299     MAKE_FUNC_INFO(krb524_init_ets),
 300     MAKE_FUNC_INFO(krb524_convert_creds_kdc),
 301     END_FUNC_INFO
 302 };
 303
 304 FUNC_INFO profile_fi[] = {
 305         MAKE_FUNC_INFO(profile_init),
 306         MAKE_FUNC_INFO(profile_release),
 307         MAKE_FUNC_INFO(profile_get_subsection_names),
 308         MAKE_FUNC_INFO(profile_free_list),
 309         MAKE_FUNC_INFO(profile_get_string),
 310         MAKE_FUNC_INFO(profile_release_string),
 311         END_FUNC_INFO
 312 };
 313
 314 FUNC_INFO ce_fi[] = {
 315     MAKE_FUNC_INFO(com_err),
 316     MAKE_FUNC_INFO(error_message),
 317     END_FUNC_INFO
 318 };
 319
 320 FUNC_INFO service_fi[] = {
 321     MAKE_FUNC_INFO(OpenSCManagerA),
 322     MAKE_FUNC_INFO(OpenServiceA),
 323     MAKE_FUNC_INFO(QueryServiceStatus),
 324     MAKE_FUNC_INFO(CloseServiceHandle),
 325 #ifdef USE_MS2MIT
 326     MAKE_FUNC_INFO(LsaNtStatusToWinError),
 327 #endif /* USE_MS2MIT */
 328     END_FUNC_INFO
 329 };
 330
 331 #ifdef USE_MS2MIT
 332 FUNC_INFO lsa_fi[] = {
 333     MAKE_FUNC_INFO(LsaConnectUntrusted),
 334     MAKE_FUNC_INFO(LsaLookupAuthenticationPackage),
 335     MAKE_FUNC_INFO(LsaCallAuthenticationPackage),
 336     MAKE_FUNC_INFO(LsaFreeReturnBuffer),
 337     MAKE_FUNC_INFO(LsaGetLogonSessionData),
 338     END_FUNC_INFO
 339 };
 340 #endif /* USE_MS2MIT */
 341
 342 /* Static Prototypes */
 343 char *afs_realm_of_cell(struct afsconf_cell *);
 344 static long get_cellconfig_callback(void *, struct sockaddr_in *, char *);
 345 int KFW_AFS_get_cellconfig(char *, struct afsconf_cell *, char *);
 346 static krb5_error_code KRB5_CALLCONV KRB5_prompter( krb5_context context,
 347            void *data, const char *name, const char *banner, int num_prompts,
 348            krb5_prompt prompts[]);
 349
 350
 351 /* Static Declarations */
 352 static int                inited = 0;
 353 static int                mid_cnt = 0;
 354 static struct textField * mid_tb = NULL;
 355 static HINSTANCE hKrb5 = 0;
 356 static HINSTANCE hKrb4 = 0;
 357 static HINSTANCE hKrb524 = 0;
 358 #ifdef USE_MS2MIT
 359 static HINSTANCE hSecur32 = 0;
 360 #endif /* USE_MS2MIT */
 361 static HINSTANCE hAdvApi32 = 0;
 362 static HINSTANCE hComErr = 0;
 363 static HINSTANCE hService = 0;
 364 static HINSTANCE hProfile = 0;
 365 static HINSTANCE hLeash = 0;
 366 static HINSTANCE hCCAPI = 0;
 367 static struct principal_ccache_data * princ_cc_data = NULL;
 368 static struct cell_principal_map    * cell_princ_map = NULL;
 369
 370 void
 371 KFW_initialize(void)
 372 {
 373     static int inited = 0;
 374
 375     if ( !inited ) {
 376         char mutexName[MAX_PATH];
 377         HANDLE hMutex = NULL;
 378
 379         sprintf(mutexName, "AFS KFW Init pid=%d", getpid());
 380
 381         hMutex = CreateMutex( NULL, TRUE, mutexName );
 382         if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
 383             if ( WaitForSingleObject( hMutex, INFINITE ) != WAIT_OBJECT_0 ) {
 384                 return;
 385             }
 386         }
 387         if ( !inited ) {
 388             inited = 1;
 389             LoadFuncs(KRB5_DLL, k5_fi, &hKrb5, 0, 1, 0, 0);
 390             LoadFuncs(KRB4_DLL, k4_fi, &hKrb4, 0, 1, 0, 0);
 391             LoadFuncs(COMERR_DLL, ce_fi, &hComErr, 0, 0, 1, 0);
 392             LoadFuncs(SERVICE_DLL, service_fi, &hService, 0, 1, 0, 0);
 393 #ifdef USE_MS2MIT
 394             LoadFuncs(SECUR32_DLL, lsa_fi, &hSecur32, 0, 1, 1, 1);
 395 #endif /* USE_MS2MIT */
 396             LoadFuncs(KRB524_DLL, k524_fi, &hKrb524, 0, 1, 1, 1);
 397             LoadFuncs(PROFILE_DLL, profile_fi, &hProfile, 0, 1, 0, 0);
 398             LoadFuncs(LEASH_DLL, leash_fi, &hLeash, 0, 1, 0, 0);
 399             LoadFuncs(CCAPI_DLL, ccapi_fi, &hCCAPI, 0, 1, 0, 0);
 400
 401             if ( KFW_is_available() ) {
 402                 char rootcell[MAXCELLCHARS+1];
 403 #ifdef USE_MS2MIT
 404                 KFW_import_windows_lsa();
 405 #endif /* USE_MS2MIT */
 406                 KFW_import_ccache_data();
 407                 KFW_AFS_renew_expiring_tokens();
 408
 409                 /* WIN32 NOTE: no way to get max chars */
 410                 if (!cm_GetRootCellName(rootcell))
 411                     KFW_AFS_renew_token_for_cell(rootcell);
 412             }
 413         }
 414         ReleaseMutex(hMutex);
 415         CloseHandle(hMutex);
 416     }
 417 }
 418
 419 void
 420 KFW_cleanup(void)
 421 {
 422     if (hKrb5)
 423         FreeLibrary(hKrb5);
 424     if (hKrb4)
 425         FreeLibrary(hKrb4);
 426     if (hProfile)
 427         FreeLibrary(hProfile);
 428     if (hComErr)
 429         FreeLibrary(hComErr);
 430     if (hService)
 431         FreeLibrary(hService);
 432 #ifdef USE_MS2MIT
 433     if (hSecur32)
 434         FreeLibrary(hSecur32);
 435 #endif /* USE_MS2MIT */
 436     if (hKrb524)
 437         FreeLibrary(hKrb524);
 438     if (hLeash)
 439         FreeLibrary(hLeash);
 440     if (hCCAPI)
 441         FreeLibrary(hCCAPI);
 442 }
 443
 444 static char OpenAFSConfigKeyName[] = "SOFTWARE\\OpenAFS\\Client";
 445
 446 int
 447 KFW_is_available(void)
 448 {
 449     HKEY parmKey;
 450         DWORD code, len;
 451     DWORD enableKFW = 1;
 452
 453     code = RegOpenKeyEx(HKEY_CURRENT_USER, OpenAFSConfigKeyName,
 454                          0, KEY_QUERY_VALUE, &parmKey);
 455     if (code != ERROR_SUCCESS)
 456         code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, OpenAFSConfigKeyName,
 457                              0, KEY_QUERY_VALUE, &parmKey);
 458         if (code == ERROR_SUCCESS) {
 459         len = sizeof(enableKFW);
 460         code = RegQueryValueEx(parmKey, "EnableKFW", NULL, NULL,
 461                                 (BYTE *) &enableKFW, &len);
 462         if (code != ERROR_SUCCESS) {
 463             enableKFW = 1;
 464         }
 465         RegCloseKey (parmKey);
 466         }
 467
 468     if ( !enableKFW )
 469         return FALSE;
 470
 471     KFW_initialize();
 472     if ( hKrb5 && hComErr && hService &&
 473 #ifdef USE_MS2MIT
 474          hSecur32 &&
 475 #endif /* USE_MS2MIT */
 476          hKrb524 &&
 477          hProfile && hLeash && hCCAPI )
 478         return TRUE;
 479     return FALSE;
 480 }
 481
 482 int
 483 KRB5_error(krb5_error_code rc, LPCSTR FailedFunctionName,
 484                  int FreeContextFlag, krb5_context * ctx,
 485                  krb5_ccache * cache)
 486 {
 487     char message[256];
 488     const char *errText;
 489     int krb5Error = ((int)(rc & 255));
 490
 491     /*
 492     switch (krb5Error)
 493     {
 494         // Wrong password
 495         case 31:
 496         case 8:
 497             return;
 498     }
 499     */
 500
 501     errText = perror_message(rc);
 502     _snprintf(message, sizeof(message),
 503               "%s\n(Kerberos error %ld)\n\n%s failed",
 504               errText,
 505               krb5Error,
 506               FailedFunctionName);
 507
 508     if ( IsDebuggerPresent() )
 509         OutputDebugString(message);
 510
 511     MessageBox(NULL, message, "Kerberos Five", MB_OK | MB_ICONERROR |
 512                MB_TASKMODAL |
 513                MB_SETFOREGROUND);
 514     if (FreeContextFlag == 1)
 515     {
 516         if (ctx && *ctx != NULL)
 517         {
 518             if (cache && *cache != NULL) {
 519                 pkrb5_cc_close(*ctx, *cache);
 520                                 *cache = NULL;
 521                         }
 522
 523             pkrb5_free_context(*ctx);
 524                         *ctx = NULL;
 525         }
 526     }
 527
 528     return rc;
 529 }
 530
 531 void
 532 KFW_AFS_update_princ_ccache_data(krb5_context ctx, krb5_ccache cc, int lsa)
 533 {
 534     struct principal_ccache_data * next = princ_cc_data;
 535     krb5_principal principal = 0;
 536     char * pname = NULL;
 537     const char * ccname = NULL;
 538     krb5_error_code code = 0;
 539     krb5_error_code cc_code = 0;
 540     krb5_cc_cursor cur;
 541     krb5_creds creds;
 542     krb5_flags flags=0;
 543     krb5_timestamp now;
 544
 545     if (ctx == 0 || cc == 0)
 546         return;
 547
 548     code = pkrb5_cc_get_principal(ctx, cc, &principal);
 549     if ( code ) return;
 550
 551     code = pkrb5_unparse_name(ctx, principal, &pname);
 552     if ( code ) goto cleanup;
 553
 554     ccname = pkrb5_cc_get_name(ctx, cc);
 555     if (!ccname) goto cleanup;
 556
 557     // Search the existing list to see if we have a match
 558     if ( next ) {
 559         for ( ; next ; next = next->next ) {
 560             if ( !strcmp(next->principal,pname) && !strcmp(next->ccache_name, ccname) )
 561                 break;
 562         }
 563     }
 564
 565     // If not, match add a new node to the beginning of the list and assign init it
 566     if ( !next ) {
 567         next = (struct principal_ccache_data *) malloc(sizeof(struct principal_ccache_data));
 568         next->next = princ_cc_data;
 569         princ_cc_data = next;
 570         next->principal = _strdup(pname);
 571         next->ccache_name = _strdup(ccname);
 572         next->from_lsa = lsa;
 573         next->expired = 1;
 574         next->expiration_time = 0;
 575         next->renew = 0;
 576     }
 577
 578     flags = 0;  // turn off OPENCLOSE mode
 579     code = pkrb5_cc_set_flags(ctx, cc, flags);
 580     if ( code ) goto cleanup;
 581
 582     code = pkrb5_timeofday(ctx, &now);
 583
 584     cc_code = pkrb5_cc_start_seq_get(ctx, cc, &cur);
 585
 586     while (!(cc_code = pkrb5_cc_next_cred(ctx, cc, &cur, &creds))) {
 587         if ( creds.ticket_flags & TKT_FLG_INITIAL ) {
 588             int valid;
 589             // we found the ticket we are looking for
 590             // check validity of timestamp
 591             // We add a 5 minutes fudge factor to compensate for potential
 592             // clock skew errors between the KDC and client OS
 593
 594             valid = ((creds.times.starttime > 0) &&
 595                      now >= (creds.times.starttime - 300) &&
 596                      now < (creds.times.endtime + 300) &&
 597                      !(creds.ticket_flags & TKT_FLG_INVALID));
 598
 599             if ( next->from_lsa) {
 600                 next->expired = 0;
 601                 next->expiration_time = creds.times.endtime;
 602                 next->renew = 1;
 603             } else if ( valid ) {
 604                 next->expired = 0;
 605                 next->expiration_time = creds.times.endtime;
 606                 next->renew = (creds.times.renew_till > creds.times.endtime) &&
 607                                (creds.ticket_flags & TKT_FLG_RENEWABLE);
 608             } else {
 609                 next->expired = 1;
 610                 next->expiration_time = 0;
 611                 next->renew = 0;
 612             }
 613
 614             pkrb5_free_cred_contents(ctx, &creds);
 615             cc_code = KRB5_CC_END;
 616             break;
 617         }
 618         pkrb5_free_cred_contents(ctx, &creds);
 619     }
 620
 621     if (cc_code == KRB5_CC_END) {
 622         code = pkrb5_cc_end_seq_get(ctx, cc, &cur);
 623         if (code) goto cleanup;
 624     }
 625
 626   cleanup:
 627     flags = KRB5_TC_OPENCLOSE;  //turn on OPENCLOSE
 628     code = pkrb5_cc_set_flags(ctx, cc, flags);
 629
 630     if ( pname )
 631         pkrb5_free_unparsed_name(ctx,pname);
 632     if ( principal )
 633         pkrb5_free_principal(ctx,principal);
 634 }
 635
 636 int
 637 KFW_AFS_find_ccache_for_principal(krb5_context ctx, char * principal, char **ccache, int valid_only)
 638 {
 639     struct principal_ccache_data * next = princ_cc_data;
 640     char * response = NULL;
 641
 642     if ( !principal || !ccache )
 643         return 0;
 644
 645     while ( next ) {
 646         if ( (!valid_only || !next->expired) && !strcmp(next->principal,principal) ) {
 647             if (response) {
 648                 // we always want to prefer the MS Kerberos LSA cache or
 649                 // the cache afscreds created specifically for the principal
 650                 // if the current entry is either one, drop the previous find
 651                 if ( next->from_lsa || !strcmp(next->ccache_name,principal) )
 652                     free(response);
 653             }
 654             response = _strdup(next->ccache_name);
 655             // MS Kerberos LSA is our best option so use it and quit
 656             if ( next->from_lsa )
 657                 break;
 658         }
 659         next = next->next;
 660     }
 661
 662     if ( response ) {
 663         *ccache = response;
 664         return 1;
 665     }
 666     return 0;
 667 }
 668
 669 void
 670 KFW_AFS_delete_princ_ccache_data(krb5_context ctx, char * pname, char * ccname)
 671 {
 672     struct principal_ccache_data ** next = &princ_cc_data;
 673
 674     if ( !pname && !ccname )
 675         return;
 676
 677     while ( (*next) ) {
 678         if ( !strcmp((*next)->principal,pname) ||
 679              !strcmp((*next)->ccache_name,ccname) ) {
 680             void * temp;
 681             free((*next)->principal);
 682             free((*next)->ccache_name);
 683             temp = (*next);
 684             (*next) = (*next)->next;
 685             free(temp);
 686         }
 687     }
 688 }
 689
 690 void
 691 KFW_AFS_update_cell_princ_map(krb5_context ctx, char * cell, char *pname, int active)
 692 {
 693     struct cell_principal_map * next = cell_princ_map;
 694
 695     // Search the existing list to see if we have a match
 696     if ( next ) {
 697         for ( ; next ; next = next->next ) {
 698             if ( !strcmp(next->cell, cell) ) {
 699                 if ( !strcmp(next->principal,pname) ) {
 700                     next->active = active;
 701                                         break;
 702                 } else {
 703                     // OpenAFS currently has a restriction of one active token per cell
 704                     // Therefore, whenever we update the table with a new active cell we
 705                     // must mark all of the other principal to cell entries as inactive.
 706                     if (active)
 707                         next->active = 0;
 708                 }
 709             }
 710         }
 711     }
 712
 713     // If not, match add a new node to the beginning of the list and assign init it
 714     if ( !next ) {
 715         next = (struct cell_principal_map *) malloc(sizeof(struct cell_principal_map));
 716         next->next = cell_princ_map;
 717         cell_princ_map = next;
 718         next->principal = _strdup(pname);
 719         next->cell = _strdup(cell);
 720         next->active = active;
 721     }
 722 }
 723
 724 void
 725 KFW_AFS_delete_cell_princ_maps(krb5_context ctx, char * pname, char * cell)
 726 {
 727     struct cell_principal_map ** next = &cell_princ_map;
 728
 729     if ( !pname && !cell )
 730         return;
 731
 732     while ( (*next) ) {
 733         if ( !strcmp((*next)->principal,pname) ||
 734              !strcmp((*next)->cell,cell) ) {
 735             void * temp;
 736             free((*next)->principal);
 737             free((*next)->cell);
 738             temp = (*next);
 739             (*next) = (*next)->next;
 740             free(temp);
 741         }
 742     }
 743 }
 744
 745 // Returns (if possible) a principal which has been known in
 746 // the past to have been used to obtain tokens for the specified
 747 // cell.
 748 // TODO: Attempt to return one which has not yet expired by checking
 749 // the principal/ccache data
 750 int
 751 KFW_AFS_find_principals_for_cell(krb5_context ctx, char * cell, char **principals[], int active_only)
 752 {
 753     struct cell_principal_map * next_map = cell_princ_map;
 754     const char * princ = NULL;
 755     int count = 0, i;
 756
 757     if ( !cell )
 758         return 0;
 759
 760     while ( next_map ) {
 761         if ( (!active_only || next_map->active) && !strcmp(next_map->cell,cell) ) {
 762             count++;
 763         }
 764         next_map = next_map->next;
 765     }
 766
 767     if ( !principals || !count )
 768         return count;
 769
 770     *principals = (char **) malloc(sizeof(char *) * count);
 771     for ( next_map = cell_princ_map, i=0 ; next_map && i<count; next_map = next_map->next )
 772     {
 773         if ( (!active_only || next_map->active) && !strcmp(next_map->cell,cell) ) {
 774             (*principals)[i++] = _strdup(next_map->principal);
 775         }
 776     }
 777     return count;
 778 }
 779
 780 int
 781 KFW_AFS_find_cells_for_princ(krb5_context ctx, char * pname, char **cells[], int active_only)
 782 {
 783     int     count = 0, i;
 784     struct cell_principal_map * next_map = cell_princ_map;
 785     const char * princ = NULL;
 786
 787     if ( !pname )
 788         return 0;
 789
 790     while ( next_map ) {
 791         if ( (!active_only || next_map->active) && !strcmp(next_map->principal,pname) ) {
 792             count++;
 793         }
 794         next_map = next_map->next;
 795     }
 796
 797     if ( !cells )
 798         return count;
 799
 800     *cells = (char **) malloc(sizeof(char *) * count);
 801     for ( next_map = cell_princ_map, i=0 ; next_map && i<count; next_map = next_map->next )
 802     {
 803         if ( (!active_only || next_map->active) && !strcmp(next_map->principal,pname) ) {
 804             (*cells)[i++] = _strdup(next_map->cell);
 805         }
 806     }
 807     return count;
 808 }
 809
 810 /* Given a principal return an existing ccache or create one and return */
 811 int
 812 KFW_get_ccache(krb5_context alt_ctx, krb5_principal principal, krb5_ccache * cc)
 813 {
 814     krb5_context ctx;
 815     char * pname = 0;
 816     char * ccname = 0;
 817     krb5_error_code code;
 818
 819     if (!pkrb5_init_context)
 820         return 0;
 821
 822     if ( alt_ctx ) {
 823         ctx = alt_ctx;
 824     } else {
 825         code = pkrb5_init_context(&ctx);
 826         if (code) goto cleanup;
 827     }
 828
 829     if ( principal ) {
 830         code = pkrb5_unparse_name(ctx, principal, &pname);
 831         if (code) goto cleanup;
 832
 833         if ( !KFW_AFS_find_ccache_for_principal(ctx,pname,&ccname,TRUE) &&
 834              !KFW_AFS_find_ccache_for_principal(ctx,pname,&ccname,FALSE)) {
 835             ccname = (char *)malloc(strlen(pname) + 5);
 836             sprintf(ccname,"API:%s",pname);
 837         }
 838         code = pkrb5_cc_resolve(ctx, ccname, cc);
 839     } else {
 840         code = pkrb5_cc_default(ctx, cc);
 841         if (code) goto cleanup;
 842     }
 843
 844   cleanup:
 845     if (ccname)
 846         free(ccname);
 847     if (pname)
 848         pkrb5_free_unparsed_name(ctx,pname);
 849     if (ctx && (ctx != alt_ctx))
 850         pkrb5_free_context(ctx);
 851     return(code);
 852 }
 853
 854 #ifdef USE_MS2MIT
 855 // Import Microsoft Credentials into a new MIT ccache
 856 void
 857 KFW_import_windows_lsa(void)
 858 {
 859     krb5_context ctx = 0;
 860     krb5_ccache  cc = 0;
 861     krb5_principal princ = 0;
 862     char * pname = NULL;
 863     krb5_data *  realm;
 864     krb5_error_code code;
 865     char cell[128]="";
 866     int i;
 867
 868     if (!pkrb5_init_context)
 869         return;
 870
 871 #ifdef COMMENT
 872     if ( !MSLSA_IsKerberosLogon() )
 873         return;
 874 #endif
 875
 876     code = pkrb5_init_context(&ctx);
 877     if (code) goto cleanup;
 878
 879     code = pkrb5_cc_resolve(ctx, LSA_CCNAME, &cc);
 880     if (code) goto cleanup;
 881
 882     KFW_AFS_update_princ_ccache_data(ctx, cc, TRUE);
 883
 884     code = pkrb5_cc_get_principal(ctx, cc, &princ);
 885     if ( code ) goto cleanup;
 886
 887     code = pkrb5_unparse_name(ctx,princ,&pname);
 888     if ( code ) goto cleanup;
 889
 890     realm = krb5_princ_realm(ctx, princ);
 891     for ( i=0; i<realm->length; i++ ) {
 892         cell[i] = tolower(realm->data[i]);
 893     }
 894         cell[i] = '\0';
 895
 896     code = KFW_AFS_klog(ctx, cc, "afs", cell, realm->data, pLeash_get_default_lifetime(),NULL);
 897     if ( IsDebuggerPresent() ) {
 898         char message[256];
 899         sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
 900         OutputDebugString(message);
 901     }
 902     if ( code ) goto cleanup;
 903
 904     KFW_AFS_update_cell_princ_map(ctx, cell, pname, TRUE);
 905
 906   cleanup:
 907     if (pname)
 908         pkrb5_free_unparsed_name(ctx,pname);
 909     if (princ)
 910         pkrb5_free_principal(ctx,princ);
 911     if (cc)
 912         pkrb5_cc_close(ctx,cc);
 913     if (ctx)
 914         pkrb5_free_context(ctx);
 915 }
 916 #endif /* USE_MS2MIT */
 917
 918 // If there are existing MIT credentials, copy them to a new
 919 // ccache named after the principal
 920
 921 // Enumerate all existing MIT ccaches and construct entries
 922 // in the principal_ccache table
 923
 924 // Enumerate all existing AFS Tokens and construct entries
 925 // in the cell_principal table
 926 void
 927 KFW_import_ccache_data(void)
 928 {
 929     krb5_context ctx = 0;
 930     krb5_ccache  cc = 0;
 931     krb5_principal principal = 0;
 932     krb5_creds creds;
 933     krb5_error_code code;
 934     krb5_error_code cc_code;
 935     krb5_cc_cursor cur;
 936     apiCB * cc_ctx = 0;
 937     struct _infoNC ** pNCi = NULL;
 938     int i, j, flags;
 939
 940     if ( !pcc_initialize )
 941         return;
 942
 943     if ( IsDebuggerPresent() )
 944         OutputDebugString("KFW_import_ccache_data()\n");
 945
 946     code = pcc_initialize(&cc_ctx, CC_API_VER_2, NULL, NULL);
 947     if (code) goto cleanup;
 948
 949     code = pcc_get_NC_info(cc_ctx, &pNCi);
 950     if (code) goto cleanup;
 951
 952     code = pkrb5_init_context(&ctx);
 953     if (code) goto cleanup;
 954
 955     for ( i=0; pNCi[i]; i++ ) {
 956         if ( pNCi[i]->vers != CC_CRED_V5 )
 957             continue;
 958         if ( IsDebuggerPresent() ) {
 959             OutputDebugString("Principal: ");
 960             OutputDebugString(pNCi[i]->principal);
 961             OutputDebugString(" in ccache ");
 962             OutputDebugString(pNCi[i]->name);
 963             OutputDebugString("\n");
 964         }
 965         if ( strcmp(pNCi[i]->name,pNCi[i]->principal)
 966              && strcmp(pNCi[i]->name,LSA_CCNAME)
 967              ) {
 968             int found = 0;
 969             for ( j=0; pNCi[j]; j++ ) {
 970                 if (!strcmp(pNCi[j]->name,pNCi[i]->principal)) {
 971                     found = 1;
 972                     break;
 973                 }
 974             }
 975
 976             code = pkrb5_cc_resolve(ctx, pNCi[i]->principal, &cc);
 977             if (code) goto loop_cleanup;
 978
 979             if (!found) {
 980                 krb5_ccache oldcc = 0;
 981
 982                 if ( IsDebuggerPresent() )
 983                     OutputDebugString("copying ccache data to new ccache\n");
 984
 985                 code = pkrb5_parse_name(ctx, pNCi[i]->principal, &principal);
 986                 if (code) goto loop_cleanup;
 987                 code = pkrb5_cc_initialize(ctx, cc, principal);
 988                 if (code) goto loop_cleanup;
 989
 990                 code = pkrb5_cc_resolve(ctx, pNCi[i]->name, &oldcc);
 991                 if (code) goto loop_cleanup;
 992                 code = pkrb5_cc_copy_creds(ctx,oldcc,cc);
 993                 if (code) {
 994                     code = pkrb5_cc_close(ctx,cc);
 995                     cc = 0;
 996                     code = pkrb5_cc_close(ctx,oldcc);
 997                     cc = 0;
 998                     KRB5_error(code, "krb5_cc_copy_creds", 0, NULL, NULL);
 999                     continue;
1000                 }
1001                 code = pkrb5_cc_close(ctx,oldcc);
1002             }
1003         } else {
1004             code = pkrb5_cc_resolve(ctx, pNCi[i]->name, &cc);
1005             if (code) goto loop_cleanup;
1006         }
1007
1008         flags = 0;  // turn off OPENCLOSE mode
1009         code = pkrb5_cc_set_flags(ctx, cc, flags);
1010         if ( code ) goto cleanup;
1011
1012         KFW_AFS_update_princ_ccache_data(ctx, cc, !strcmp(pNCi[i]->name,LSA_CCNAME));
1013
1014         cc_code = pkrb5_cc_start_seq_get(ctx, cc, &cur);
1015
1016         while (!(cc_code = pkrb5_cc_next_cred(ctx, cc, &cur, &creds))) {
1017             krb5_data * sname = krb5_princ_name(ctx, creds.server);
1018             krb5_data * cell  = krb5_princ_component(ctx, creds.server, 1);
1019             krb5_data * realm = krb5_princ_realm(ctx, creds.server);
1020             if ( sname && cell && !strcmp("afs",sname->data) ) {
1021                 struct ktc_principal    aserver;
1022                 struct ktc_principal    aclient;
1023                 struct ktc_token        atoken;
1024                 int active = TRUE;
1025
1026                 if ( IsDebuggerPresent() )  {
1027                     OutputDebugString("Found AFS ticket: ");
1028                     OutputDebugString(sname->data);
1029                     if ( cell->data ) {
1030                         OutputDebugString("/");
1031                         OutputDebugString(cell->data);
1032                     }
1033                     OutputDebugString("@");
1034                     OutputDebugString(realm->data);
1035                     OutputDebugString("\n");
1036                 }
1037
1038                 memset(&aserver, '\0', sizeof(aserver));
1039                 strcpy(aserver.name, sname->data);
1040                 strcpy(aserver.cell, cell->data);
1041
1042                 code = ktc_GetToken(&aserver, &atoken, sizeof(atoken), &aclient);
1043                 if (!code) {
1044                     // Found a token in AFS Client Server which matches
1045                     char pname[128], *p, *q;
1046                     for ( p=pname, q=aclient.name; *q; p++, q++)
1047                         *p = *q;
1048                     for ( *p++ = '@', q=aclient.cell; *q; p++, q++)
1049                         *p = toupper(*q);
1050                     *p = '\0';
1051
1052                     if ( IsDebuggerPresent() )  {
1053                         OutputDebugString("Found AFS token: ");
1054                         OutputDebugString(pname);
1055                         OutputDebugString("\n");
1056                     }
1057
1058                     if ( strcmp(pname,pNCi[i]->principal)  )
1059                         active = FALSE;
1060                     KFW_AFS_update_cell_princ_map(ctx, cell->data, pNCi[i]->principal, active);
1061                 } else {
1062                     // Attempt to import it
1063                     KFW_AFS_update_cell_princ_map(ctx, cell->data, pNCi[i]->principal, active);
1064
1065                     if ( IsDebuggerPresent() )  {
1066                         OutputDebugString("Calling KFW_AFS_klog() to obtain token\n");
1067                     }
1068
1069                     code = KFW_AFS_klog(ctx, cc, "afs", cell->data, realm->data, pLeash_get_default_lifetime(),NULL);
1070                     if ( IsDebuggerPresent() ) {
1071                         char message[256];
1072                         sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1073                         OutputDebugString(message);
1074                     }
1075                 }
1076             } else if ( IsDebuggerPresent() ) {
1077                 OutputDebugString("Found ticket: ");
1078                 OutputDebugString(sname->data);
1079                 if ( cell && cell->data ) {
1080                     OutputDebugString("/");
1081                     OutputDebugString(cell->data);
1082                 }
1083                 OutputDebugString("@");
1084                 OutputDebugString(realm->data);
1085                 OutputDebugString("\n");
1086             }
1087             pkrb5_free_cred_contents(ctx, &creds);
1088         }
1089
1090         if (cc_code == KRB5_CC_END) {
1091             cc_code = pkrb5_cc_end_seq_get(ctx, cc, &cur);
1092             if (cc_code) goto loop_cleanup;
1093         }
1094
1095       loop_cleanup:
1096         flags = KRB5_TC_OPENCLOSE;  //turn on OPENCLOSE
1097         code = pkrb5_cc_set_flags(ctx, cc, flags);
1098         if (cc) {
1099             pkrb5_cc_close(ctx,cc);
1100             cc = 0;
1101         }
1102         if (principal) {
1103             pkrb5_free_principal(ctx,principal);
1104             principal = 0;
1105         }
1106     }
1107
1108   cleanup:
1109     if (ctx)
1110         pkrb5_free_context(ctx);
1111     if (pNCi)
1112         pcc_free_NC_info(cc_ctx, &pNCi);
1113     if (cc_ctx)
1114         pcc_shutdown(&cc_ctx);
1115 }
1116
1117
1118 int
1119 KFW_AFS_get_cred(char * username,
1120                   char * cell,
1121                   char * password,
1122                   int lifetime,
1123                   char * smbname,
1124                   char ** reasonP )
1125 {
1126     krb5_context ctx = 0;
1127     krb5_ccache cc = 0;
1128     char * realm = 0;
1129     char ** realmlist = 0;
1130     krb5_principal principal = 0;
1131     char * pname = 0;
1132     krb5_error_code code;
1133         char local_cell[MAXCELLCHARS+1];
1134     char **cells = NULL;
1135     int  cell_count=0;
1136     struct afsconf_cell cellconfig;
1137
1138     if (!pkrb5_init_context)
1139         return 0;
1140
1141     if ( IsDebuggerPresent() ) {
1142         OutputDebugString("KFW_AFS_get_cred for token ");
1143         OutputDebugString(username);
1144         OutputDebugString(" in cell ");
1145         OutputDebugString(cell);
1146         OutputDebugString("\n");
1147     }
1148
1149     code = pkrb5_init_context(&ctx);
1150     if ( code ) goto cleanup;
1151
1152     code = KFW_AFS_get_cellconfig( cell, (void*)&cellconfig, local_cell);
1153     if ( code ) goto cleanup;
1154
1155     realm = strchr(username,'@');
1156     if (realm) {
1157         *realm = '\0';
1158         realm++;
1159     }
1160     if ( !realm || !realm[0] )
1161         realm = afs_realm_of_cell(&cellconfig);  // do not free
1162
1163     if ( IsDebuggerPresent() ) {
1164         OutputDebugString("Realm: ");
1165         OutputDebugString(realm);
1166         OutputDebugString("\n");
1167     }
1168
1169     code = pkrb5_build_principal(ctx, &principal, strlen(realm),
1170                                  realm, username,
1171                                  NULL,
1172                                  NULL);
1173
1174     code = KFW_get_ccache(ctx, principal, &cc);
1175     if ( code ) goto cleanup;
1176
1177     code = pkrb5_unparse_name(ctx, principal, &pname);
1178     if ( code ) goto cleanup;
1179
1180     if ( lifetime == 0 )
1181         lifetime = pLeash_get_default_lifetime();
1182
1183     code = KFW_kinit(ctx, cc, HWND_DESKTOP,
1184                       pname,
1185                       password,
1186                       lifetime,
1187                       pLeash_get_default_forwardable(),
1188                       pLeash_get_default_proxiable(),
1189                       pLeash_get_default_renewable() ? pLeash_get_default_renew_till() : 0,
1190                       pLeash_get_default_noaddresses(),
1191                       pLeash_get_default_publicip());
1192     if ( IsDebuggerPresent() ) {
1193         char message[256];
1194         sprintf(message,"KFW_kinit() returns: %d\n",code);
1195         OutputDebugString(message);
1196     }
1197     if ( code ) goto cleanup;
1198
1199     KFW_AFS_update_princ_ccache_data(ctx, cc, FALSE);
1200
1201     code = KFW_AFS_klog(ctx, cc, "afs", cell, realm, lifetime,smbname);
1202     if ( IsDebuggerPresent() ) {
1203         char message[256];
1204         sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1205         OutputDebugString(message);
1206     }
1207     if ( code ) goto cleanup;
1208
1209     KFW_AFS_update_cell_princ_map(ctx, cell, pname, TRUE);
1210
1211     // Attempt to obtain new tokens for other cells supported by the same
1212     // principal
1213     cell_count = KFW_AFS_find_cells_for_princ(ctx, pname, &cells, TRUE);
1214     if ( cell_count > 1 ) {
1215         while ( cell_count-- ) {
1216             if ( strcmp(cells[cell_count],cell) ) {
1217                 if ( IsDebuggerPresent() ) {
1218                     char message[256];
1219                     sprintf(message,"found another cell for the same principal: %s\n",cell);
1220                     OutputDebugString(message);
1221                 }
1222                 code = KFW_AFS_get_cellconfig( cells[cell_count], (void*)&cellconfig, local_cell);
1223                 if ( code ) continue;
1224
1225                 realm = afs_realm_of_cell(&cellconfig);  // do not free
1226                 if ( IsDebuggerPresent() ) {
1227                     OutputDebugString("Realm: ");
1228                     OutputDebugString(realm);
1229                     OutputDebugString("\n");
1230                 }
1231
1232                 code = KFW_AFS_klog(ctx, cc, "afs", cells[cell_count], realm, lifetime,smbname);
1233                 if ( IsDebuggerPresent() ) {
1234                     char message[256];
1235                     sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1236                     OutputDebugString(message);
1237                 }
1238             }
1239             free(cells[cell_count]);
1240         }
1241         free(cells);
1242     } else if ( cell_count == 1 ) {
1243         free(cells[0]);
1244         free(cells);
1245     }
1246
1247   cleanup:
1248     if ( pname )
1249         pkrb5_free_unparsed_name(ctx,pname);
1250     if ( cc )
1251         pkrb5_cc_close(ctx, cc);
1252
1253     if ( code && reasonP ) {
1254         *reasonP = (char *)perror_message(code);
1255     }
1256     return(code);
1257 }
1258
1259 int
1260 KFW_AFS_destroy_tickets_for_cell(char * cell)
1261 {
1262     krb5_context                ctx = 0;
1263     krb5_error_code             code;
1264     int count;
1265     char ** principals = NULL;
1266
1267     if (!pkrb5_init_context)
1268         return 0;
1269
1270     if ( IsDebuggerPresent() ) {
1271         OutputDebugString("KFW_AFS_destroy_ticets_for_cell: ");
1272         OutputDebugString(cell);
1273         OutputDebugString("\n");
1274     }
1275
1276     code = pkrb5_init_context(&ctx);
1277     if (code) ctx = 0;
1278
1279     count = KFW_AFS_find_principals_for_cell(ctx, cell, &principals, FALSE);
1280     if ( count > 0 ) {
1281         krb5_principal      princ = 0;
1282         krb5_ccache                     cc  = 0;
1283
1284         while ( count-- ) {
1285             int cell_count = KFW_AFS_find_cells_for_princ(ctx, principals[count], NULL, TRUE);
1286             if ( cell_count > 1 ) {
1287                 // TODO - What we really should do here is verify whether or not any of the
1288                 // other cells which use this principal to obtain its credentials actually
1289                 // have valid tokens or not.  If they are currently using these credentials
1290                 // we will skip them.  For the time being we assume that if there is an active
1291                 // map in the table that they are actively being used.
1292                 goto loop_cleanup;
1293             }
1294
1295             code = pkrb5_parse_name(ctx, principals[count], &princ);
1296             if (code) goto loop_cleanup;
1297
1298             code = KFW_get_ccache(ctx, princ, &cc);
1299             if (code) goto loop_cleanup;
1300
1301             code = pkrb5_cc_destroy(ctx, cc);
1302             if (!code) cc = 0;
1303
1304           loop_cleanup:
1305             if ( cc ) {
1306                 pkrb5_cc_close(ctx, cc);
1307                 cc = 0;
1308             }
1309             if ( princ ) {
1310                 pkrb5_free_principal(ctx, princ);
1311                 princ = 0;
1312             }
1313
1314             KFW_AFS_update_cell_princ_map(ctx, cell, principals[count], FALSE);
1315             free(principals[count]);
1316         }
1317         free(principals);
1318     }
1319     pkrb5_free_context(ctx);
1320     return 0;
1321 }
1322
1323 int
1324 KFW_AFS_renew_expiring_tokens(void)
1325 {
1326     krb5_error_code                     code = 0;
1327     krb5_context                        ctx = 0;
1328     krb5_ccache                         cc = 0;
1329     krb5_timestamp now;
1330     struct principal_ccache_data * pcc_next = princ_cc_data;
1331     int cell_count;
1332     char ** cells=NULL;
1333     const char * realm = NULL;
1334     char local_cell[MAXCELLCHARS+1]="";
1335     struct afsconf_cell cellconfig;
1336
1337     if (!pkrb5_init_context)
1338         return 0;
1339
1340     if ( pcc_next == NULL ) // nothing to do
1341         return 0;
1342
1343     if ( IsDebuggerPresent() ) {
1344         OutputDebugString("KFW_AFS_renew_expiring_tokens\n");
1345     }
1346
1347     code = pkrb5_init_context(&ctx);
1348     if (code) goto cleanup;
1349
1350     code = pkrb5_timeofday(ctx, &now);
1351     if (code) goto cleanup;
1352
1353     for ( ; pcc_next ; pcc_next = pcc_next->next ) {
1354         if ( pcc_next->expired )
1355             continue;
1356
1357         if ( now >= (pcc_next->expiration_time) ) {
1358             if ( !pcc_next->from_lsa ) {
1359                 pcc_next->expired = 1;
1360                 continue;
1361             }
1362         }
1363
1364         if ( pcc_next->renew && now >= (pcc_next->expiration_time - cminRENEW * csec1MINUTE) ) {
1365             code = pkrb5_cc_resolve(ctx, pcc_next->ccache_name, &cc);
1366             if ( code )
1367                                 goto loop_cleanup;
1368             code = KFW_renew(ctx,cc);
1369 #ifdef USE_MS2MIT
1370             if ( code && pcc_next->from_lsa)
1371                 goto loop_cleanup;
1372 #endif /* USE_MS2MIT */
1373
1374
1375             KFW_AFS_update_princ_ccache_data(ctx, cc, pcc_next->from_lsa);
1376             if (code) goto loop_cleanup;
1377
1378             // Attempt to obtain new tokens for other cells supported by the same
1379             // principal
1380             cell_count = KFW_AFS_find_cells_for_princ(ctx, pcc_next->principal, &cells, TRUE);
1381             if ( cell_count > 0 ) {
1382                 while ( cell_count-- ) {
1383                     if ( IsDebuggerPresent() ) {
1384                         OutputDebugString("Cell: ");
1385                         OutputDebugString(cells[cell_count]);
1386                         OutputDebugString("\n");
1387                     }
1388                     code = KFW_AFS_get_cellconfig( cells[cell_count], (void*)&cellconfig, local_cell);
1389                     if ( code ) continue;
1390                     realm = afs_realm_of_cell(&cellconfig);  // do not free
1391                     if ( IsDebuggerPresent() ) {
1392                         OutputDebugString("Realm: ");
1393                         OutputDebugString(realm);
1394                         OutputDebugString("\n");
1395                     }
1396                     code = KFW_AFS_klog(ctx, cc, "afs", cells[cell_count], (char *)realm, pLeash_get_default_lifetime(),NULL);
1397                     if ( IsDebuggerPresent() ) {
1398                         char message[256];
1399                         sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1400                         OutputDebugString(message);
1401                     }
1402                     free(cells[cell_count]);
1403                 }
1404                 free(cells);
1405             }
1406         }
1407
1408       loop_cleanup:
1409         if ( cc ) {
1410             pkrb5_cc_close(ctx,cc);
1411             cc = 0;
1412         }
1413     }
1414
1415   cleanup:
1416     if ( cc )
1417         pkrb5_cc_close(ctx,cc);
1418     if ( ctx )
1419         pkrb5_free_context(ctx);
1420
1421     return 0;
1422 }
1423
1424
1425 BOOL
1426 KFW_AFS_renew_token_for_cell(char * cell)
1427 {
1428     krb5_error_code                     code = 0;
1429     krb5_context                        ctx = 0;
1430     int count;
1431     char ** principals = NULL;
1432
1433     if (!pkrb5_init_context)
1434         return 0;
1435
1436     if ( IsDebuggerPresent() ) {
1437         OutputDebugString("KFW_AFS_renew_token_for_cell:");
1438         OutputDebugString(cell);
1439         OutputDebugString("\n");
1440     }
1441
1442     code = pkrb5_init_context(&ctx);
1443     if (code) goto cleanup;
1444
1445     count = KFW_AFS_find_principals_for_cell(ctx, cell, &principals, TRUE);
1446     if ( count == 0 ) {
1447         // We know we must have a credential somewhere since we are
1448         // trying to renew a token
1449
1450         KFW_import_ccache_data();
1451         count = KFW_AFS_find_principals_for_cell(ctx, cell, &principals, TRUE);
1452     }
1453     if ( count > 0 ) {
1454         krb5_principal      princ = 0;
1455         krb5_principal      service = 0;
1456 #ifdef COMMENT
1457         krb5_creds          mcreds, creds;
1458 #endif /* COMMENT */
1459         krb5_ccache                     cc  = 0;
1460         const char * realm = NULL;
1461         struct afsconf_cell cellconfig;
1462         char local_cell[MAXCELLCHARS+1];
1463
1464         while ( count-- ) {
1465             code = pkrb5_parse_name(ctx, principals[count], &princ);
1466             if (code) goto loop_cleanup;
1467
1468             code = KFW_get_ccache(ctx, princ, &cc);
1469             if (code) goto loop_cleanup;
1470
1471             code = KFW_AFS_get_cellconfig( cell, (void*)&cellconfig, local_cell);
1472             if ( code ) goto loop_cleanup;
1473
1474             realm = afs_realm_of_cell(&cellconfig);  // do not free
1475             if ( IsDebuggerPresent() ) {
1476                 OutputDebugString("Realm: ");
1477                 OutputDebugString(realm);
1478                 OutputDebugString("\n");
1479             }
1480
1481 #ifdef COMMENT
1482             /* krb5_cc_remove_cred() is not implemented
1483              * for a single cred
1484              */
1485             code = pkrb5_build_principal(ctx, &service, strlen(realm),
1486                                           realm, "afs", cell, NULL);
1487             if (!code) {
1488                 memset(&mcreds, 0, sizeof(krb5_creds));
1489                 mcreds.client = princ;
1490                 mcreds.server = service;
1491
1492                 code = pkrb5_cc_retrieve_cred(ctx, cc, 0, &mcreds, &creds);
1493                 if (!code) {
1494                     if ( IsDebuggerPresent() ) {
1495                         char * cname, *sname;
1496                         pkrb5_unparse_name(ctx, creds.client, &cname);
1497                         pkrb5_unparse_name(ctx, creds.server, &sname);
1498                         OutputDebugString("Removing credential for client \"");
1499                         OutputDebugString(cname);
1500                         OutputDebugString("\" and service \"");
1501                         OutputDebugString(sname);
1502                         OutputDebugString("\"\n");
1503                         pkrb5_free_unparsed_name(ctx,cname);
1504                         pkrb5_free_unparsed_name(ctx,sname);
1505                     }
1506
1507                     code = pkrb5_cc_remove_cred(ctx, cc, 0, &creds);
1508                     pkrb5_free_principal(ctx, creds.client);
1509                     pkrb5_free_principal(ctx, creds.server);
1510                 }
1511             }
1512 #endif /* COMMENT */
1513
1514             code = KFW_AFS_klog(ctx, cc, "afs", cell, (char *)realm, pLeash_get_default_lifetime(),NULL);
1515             if ( IsDebuggerPresent() ) {
1516                 char message[256];
1517                 sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1518                 OutputDebugString(message);
1519             }
1520
1521           loop_cleanup:
1522             if (cc) {
1523                 pkrb5_cc_close(ctx, cc);
1524                 cc = 0;
1525             }
1526             if (princ) {
1527                 pkrb5_free_principal(ctx, princ);
1528                 princ = 0;
1529             }
1530             if (service) {
1531                 pkrb5_free_principal(ctx, service);
1532                 princ = 0;
1533             }
1534
1535             KFW_AFS_update_cell_princ_map(ctx, cell, principals[count], code ? FALSE : TRUE);
1536             free(principals[count]);
1537         }
1538         free(principals);
1539     } else
1540         code = -1;      // we did not renew the tokens
1541
1542   cleanup:
1543     pkrb5_free_context(ctx);
1544     return (code ? FALSE : TRUE);
1545
1546 }
1547
1548 int
1549 KFW_AFS_renew_tokens_for_all_cells(void)
1550 {
1551     struct cell_principal_map * next = cell_princ_map;
1552
1553     if ( IsDebuggerPresent() )
1554         OutputDebugString("KFW_AFS_renew_tokens_for_all()\n");
1555
1556     if ( !next )
1557         return 0;
1558
1559     for ( ; next ; next = next->next ) {
1560         if ( next->active )
1561             KFW_AFS_renew_token_for_cell(next->cell);
1562     }
1563     return 0;
1564 }
1565
1566 int
1567 KFW_renew(krb5_context alt_ctx, krb5_ccache alt_cc)
1568 {
1569     krb5_error_code                     code = 0;
1570     krb5_context                        ctx = 0;
1571     krb5_ccache                         cc = 0;
1572     krb5_principal                      me = 0;
1573     krb5_principal              server = 0;
1574     krb5_creds                          my_creds;
1575     krb5_data                   *realm = 0;
1576
1577     if (!pkrb5_init_context)
1578         return 0;
1579
1580         memset(&my_creds, 0, sizeof(krb5_creds));
1581
1582     if ( alt_ctx ) {
1583         ctx = alt_ctx;
1584     } else {
1585         code = pkrb5_init_context(&ctx);
1586         if (code) goto cleanup;
1587     }
1588
1589     if ( alt_cc ) {
1590         cc = alt_cc;
1591     } else {
1592         code = pkrb5_cc_default(ctx, &cc);
1593         if (code) goto cleanup;
1594     }
1595
1596     code = pkrb5_cc_get_principal(ctx, cc, &me);
1597     if (code) goto cleanup;
1598
1599     realm = krb5_princ_realm(ctx, me);
1600
1601     code = pkrb5_build_principal_ext(ctx, &server,
1602                                     realm->length,realm->data,
1603                                     KRB5_TGS_NAME_SIZE, KRB5_TGS_NAME,
1604                                     realm->length,realm->data,
1605                                     0);
1606     if ( code )
1607         goto cleanup;
1608
1609     if ( IsDebuggerPresent() ) {
1610         char * cname, *sname;
1611         pkrb5_unparse_name(ctx, me, &cname);
1612         pkrb5_unparse_name(ctx, server, &sname);
1613         OutputDebugString("Renewing credential for client \"");
1614         OutputDebugString(cname);
1615         OutputDebugString("\" and service \"");
1616         OutputDebugString(sname);
1617         OutputDebugString("\"\n");
1618         pkrb5_free_unparsed_name(ctx,cname);
1619         pkrb5_free_unparsed_name(ctx,sname);
1620     }
1621
1622     my_creds.client = me;
1623     my_creds.server = server;
1624
1625     code = pkrb5_get_renewed_creds(ctx, &my_creds, me, cc, NULL);
1626     if (code) {
1627         if ( IsDebuggerPresent() ) {
1628             char message[256];
1629             sprintf(message,"krb5_get_renewed_creds() failed: %d\n",code);
1630             OutputDebugString(message);
1631         }
1632         goto cleanup;
1633     }
1634
1635     code = pkrb5_cc_initialize(ctx, cc, me);
1636     if (code) {
1637         if ( IsDebuggerPresent() ) {
1638             char message[256];
1639             sprintf(message,"krb5_cc_initialize() failed: %d\n",code);
1640             OutputDebugString(message);
1641         }
1642         goto cleanup;
1643     }
1644
1645     code = pkrb5_cc_store_cred(ctx, cc, &my_creds);
1646     if (code) {
1647         if ( IsDebuggerPresent() ) {
1648             char message[256];
1649             sprintf(message,"krb5_cc_store_cred() failed: %d\n",code);
1650             OutputDebugString(message);
1651         }
1652         goto cleanup;
1653     }
1654
1655   cleanup:
1656     if (my_creds.client == me)
1657         my_creds.client = 0;
1658     if (my_creds.server == server)
1659         my_creds.server = 0;
1660     pkrb5_free_cred_contents(ctx, &my_creds);
1661     if (me)
1662         pkrb5_free_principal(ctx, me);
1663     if (server)
1664         pkrb5_free_principal(ctx, server);
1665     if (cc && (cc != alt_cc))
1666         pkrb5_cc_close(ctx, cc);
1667     if (ctx && (ctx != alt_ctx))
1668         pkrb5_free_context(ctx);
1669     return(code);
1670 }
1671
1672 int
1673 KFW_kinit( krb5_context alt_ctx,
1674             krb5_ccache  alt_cc,
1675             HWND hParent,
1676             char *principal_name,
1677             char *password,
1678             krb5_deltat lifetime,
1679             DWORD                       forwardable,
1680             DWORD                       proxiable,
1681             krb5_deltat                 renew_life,
1682             DWORD                       addressless,
1683             DWORD                       publicIP
1684             )
1685 {
1686     krb5_error_code                     code = 0;
1687     krb5_context                        ctx = 0;
1688     krb5_ccache                         cc = 0;
1689     krb5_principal                      me = 0;
1690     char*                       name = 0;
1691     krb5_creds                          my_creds;
1692     krb5_get_init_creds_opt     options;
1693     krb5_address **             addrs = NULL;
1694     int                         i = 0, addr_count = 0;
1695
1696     if (!pkrb5_init_context)
1697         return 0;
1698
1699     pkrb5_get_init_creds_opt_init(&options);
1700     memset(&my_creds, 0, sizeof(my_creds));
1701
1702     if (alt_ctx)
1703     {
1704         ctx = alt_ctx;
1705     }
1706     else
1707     {
1708         code = pkrb5_init_context(&ctx);
1709         if (code) goto cleanup;
1710     }
1711
1712     if ( alt_cc ) {
1713         cc = alt_cc;
1714     } else {
1715         code = pkrb5_cc_default(ctx, &cc);
1716         if (code) goto cleanup;
1717     }
1718
1719     code = pkrb5_parse_name(ctx, principal_name, &me);
1720     if (code)
1721                 goto cleanup;
1722
1723     code = pkrb5_unparse_name(ctx, me, &name);
1724     if (code)
1725                 goto cleanup;
1726
1727     if (lifetime == 0)
1728         lifetime = pLeash_get_default_lifetime();
1729     else
1730         lifetime *= 5*60;
1731
1732         if (renew_life > 0)
1733                 renew_life *= 5*60;
1734
1735     if (lifetime)
1736         pkrb5_get_init_creds_opt_set_tkt_life(&options, lifetime);
1737         pkrb5_get_init_creds_opt_set_forwardable(&options,
1738                                                  forwardable ? 1 : 0);
1739         pkrb5_get_init_creds_opt_set_proxiable(&options,
1740                                                proxiable ? 1 : 0);
1741         pkrb5_get_init_creds_opt_set_renew_life(&options,
1742                                                renew_life);
1743     if (addressless)
1744         pkrb5_get_init_creds_opt_set_address_list(&options,NULL);
1745     else {
1746                 if (publicIP)
1747         {
1748             // we are going to add the public IP address specified by the user
1749             // to the list provided by the operating system
1750             krb5_address ** local_addrs=NULL;
1751             DWORD           netIPAddr;
1752
1753             pkrb5_os_localaddr(ctx, &local_addrs);
1754             while ( local_addrs[i++] );
1755             addr_count = i + 1;
1756
1757             addrs = (krb5_address **) malloc((addr_count+1) * sizeof(krb5_address *));
1758             if ( !addrs ) {
1759                 pkrb5_free_addresses(ctx, local_addrs);
1760                 goto cleanup;
1761             }
1762             memset(addrs, 0, sizeof(krb5_address *) * (addr_count+1));
1763             i = 0;
1764             while ( local_addrs[i] ) {
1765                 addrs[i] = (krb5_address *)malloc(sizeof(krb5_address));
1766                 if (addrs[i] == NULL) {
1767                     pkrb5_free_addresses(ctx, local_addrs);
1768                     goto cleanup;
1769                 }
1770
1771                 addrs[i]->magic = local_addrs[i]->magic;
1772                 addrs[i]->addrtype = local_addrs[i]->addrtype;
1773                 addrs[i]->length = local_addrs[i]->length;
1774                 addrs[i]->contents = (unsigned char *)malloc(addrs[i]->length);
1775                 if (!addrs[i]->contents) {
1776                     pkrb5_free_addresses(ctx, local_addrs);
1777                     goto cleanup;
1778                 }
1779
1780                 memcpy(addrs[i]->contents,local_addrs[i]->contents,
1781                         local_addrs[i]->length);        /* safe */
1782                 i++;
1783             }
1784             pkrb5_free_addresses(ctx, local_addrs);
1785
1786             addrs[i] = (krb5_address *)malloc(sizeof(krb5_address));
1787             if (addrs[i] == NULL)
1788                 goto cleanup;
1789
1790             addrs[i]->magic = KV5M_ADDRESS;
1791             addrs[i]->addrtype = AF_INET;
1792             addrs[i]->length = 4;
1793             addrs[i]->contents = (unsigned char *)malloc(addrs[i]->length);
1794             if (!addrs[i]->contents)
1795                 goto cleanup;
1796
1797             netIPAddr = htonl(publicIP);
1798             memcpy(addrs[i]->contents,&netIPAddr,4);
1799
1800             pkrb5_get_init_creds_opt_set_address_list(&options,addrs);
1801
1802         }
1803     }
1804
1805     code = pkrb5_get_init_creds_password(ctx,
1806                                        &my_creds,
1807                                        me,
1808                                        password, // password
1809                                        KRB5_prompter, // prompter
1810                                        hParent, // prompter data
1811                                        0, // start time
1812                                        0, // service name
1813                                        &options);
1814     if (code)
1815                 goto cleanup;
1816
1817     code = pkrb5_cc_initialize(ctx, cc, me);
1818     if (code)
1819                 goto cleanup;
1820
1821     code = pkrb5_cc_store_cred(ctx, cc, &my_creds);
1822     if (code)
1823                 goto cleanup;
1824
1825  cleanup:
1826     if ( addrs ) {
1827         for ( i=0;i<addr_count;i++ ) {
1828             if ( addrs[i] ) {
1829                 if ( addrs[i]->contents )
1830                     free(addrs[i]->contents);
1831                 free(addrs[i]);
1832             }
1833         }
1834     }
1835     if (my_creds.client == me)
1836         my_creds.client = 0;
1837     pkrb5_free_cred_contents(ctx, &my_creds);
1838     if (name)
1839         pkrb5_free_unparsed_name(ctx, name);
1840     if (me)
1841         pkrb5_free_principal(ctx, me);
1842     if (cc && (cc != alt_cc))
1843         pkrb5_cc_close(ctx, cc);
1844     if (ctx && (ctx != alt_ctx))
1845         pkrb5_free_context(ctx);
1846     return(code);
1847 }
1848
1849
1850 int
1851 KFW_kdestroy(krb5_context alt_ctx, krb5_ccache alt_cc)
1852 {
1853     krb5_context                ctx;
1854     krb5_ccache                 cc;
1855     krb5_error_code             code;
1856
1857     if (!pkrb5_init_context)
1858         return 0;
1859
1860     if (alt_ctx)
1861     {
1862         ctx = alt_ctx;
1863     }
1864     else
1865     {
1866         code = pkrb5_init_context(&ctx);
1867         if (code) goto cleanup;
1868     }
1869
1870     if ( alt_cc ) {
1871         cc = alt_cc;
1872     } else {
1873         code = pkrb5_cc_default(ctx, &cc);
1874         if (code) goto cleanup;
1875     }
1876
1877     code = pkrb5_cc_destroy(ctx, cc);
1878     if ( !code ) cc = 0;
1879
1880   cleanup:
1881     if (cc && (cc != alt_cc))
1882         pkrb5_cc_close(ctx, cc);
1883     if (ctx && (ctx != alt_ctx))
1884         pkrb5_free_context(ctx);
1885
1886     return(code);
1887 }
1888
1889
1890 #ifdef USE_MS2MIT
1891 static BOOL
1892 GetSecurityLogonSessionData(PSECURITY_LOGON_SESSION_DATA * ppSessionData)
1893 {
1894     NTSTATUS Status = 0;
1895     HANDLE  TokenHandle;
1896     TOKEN_STATISTICS Stats;
1897     DWORD   ReqLen;
1898     BOOL    Success;
1899
1900     if (!ppSessionData)
1901         return FALSE;
1902     *ppSessionData = NULL;
1903
1904     Success = OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &TokenHandle );
1905     if ( !Success )
1906         return FALSE;
1907
1908     Success = GetTokenInformation( TokenHandle, TokenStatistics, &Stats, sizeof(TOKEN_STATISTICS), &ReqLen );
1909     CloseHandle( TokenHandle );
1910     if ( !Success )
1911         return FALSE;
1912
1913     Status = pLsaGetLogonSessionData( &Stats.AuthenticationId, ppSessionData );
1914     if ( FAILED(Status) || !ppSessionData )
1915         return FALSE;
1916
1917     return TRUE;
1918 }
1919
1920 //
1921 // MSLSA_IsKerberosLogon() does not validate whether or not there are valid tickets in the
1922 // cache.  It validates whether or not it is reasonable to assume that if we
1923 // attempted to retrieve valid tickets we could do so.  Microsoft does not
1924 // automatically renew expired tickets.  Therefore, the cache could contain
1925 // expired or invalid tickets.  Microsoft also caches the user's password
1926 // and will use it to retrieve new TGTs if the cache is empty and tickets
1927 // are requested.
1928
1929 static BOOL
1930 MSLSA_IsKerberosLogon(VOID)
1931 {
1932     PSECURITY_LOGON_SESSION_DATA pSessionData = NULL;
1933     BOOL    Success = FALSE;
1934
1935     if ( GetSecurityLogonSessionData(&pSessionData) ) {
1936         if ( pSessionData->AuthenticationPackage.Buffer ) {
1937             WCHAR buffer[256];
1938             WCHAR *usBuffer;
1939             int usLength;
1940
1941             Success = FALSE;
1942             usBuffer = (pSessionData->AuthenticationPackage).Buffer;
1943             usLength = (pSessionData->AuthenticationPackage).Length;
1944             if (usLength < 256)
1945             {
1946                 lstrcpynW (buffer, usBuffer, usLength);
1947                 lstrcatW (buffer,L"");
1948                 if ( !lstrcmpW(L"Kerberos",buffer) )
1949                     Success = TRUE;
1950             }
1951         }
1952         pLsaFreeReturnBuffer(pSessionData);
1953     }
1954     return Success;
1955 }
1956 #endif /* USE_MS2MIT */
1957
1958 static BOOL CALLBACK
1959 MultiInputDialogProc( HWND hDialog, UINT message, WPARAM wParam, LPARAM lParam)
1960 {
1961     int i;
1962
1963     switch ( message ) {
1964     case WM_INITDIALOG:
1965         if ( GetDlgCtrlID((HWND) wParam) != ID_MID_TEXT )
1966         {
1967             SetFocus(GetDlgItem( hDialog, ID_MID_TEXT));
1968             return FALSE;
1969         }
1970                 for ( i=0; i < mid_cnt ; i++ ) {
1971                         if (mid_tb[i].echo == 0)
1972                                 SendDlgItemMessage(hDialog, ID_MID_TEXT+i, EM_SETPASSWORDCHAR, 32, 0);
1973                     else if (mid_tb[i].echo == 2)
1974                                 SendDlgItemMessage(hDialog, ID_MID_TEXT+i, EM_SETPASSWORDCHAR, '*', 0);
1975                 }
1976         return TRUE;
1977
1978     case WM_COMMAND:
1979         switch ( LOWORD(wParam) ) {
1980         case IDOK:
1981             for ( i=0; i < mid_cnt ; i++ ) {
1982                 if ( !GetDlgItemText(hDialog, ID_MID_TEXT+i, mid_tb[i].buf, mid_tb[i].len) )
1983                     *mid_tb[i].buf = '\0';
1984             }
1985             /* fallthrough */
1986         case IDCANCEL:
1987             EndDialog(hDialog, LOWORD(wParam));
1988             return TRUE;
1989         }
1990     }
1991     return FALSE;
1992 }
1993
1994 static LPWORD
1995 lpwAlign( LPWORD lpIn )
1996 {
1997     ULONG ul;
1998
1999     ul = (ULONG) lpIn;
2000     ul += 3;
2001     ul >>=2;
2002     ul <<=2;
2003     return (LPWORD) ul;;
2004 }
2005
2006 /*
2007  * dialog widths are measured in 1/4 character widths
2008  * dialog height are measured in 1/8 character heights
2009  */
2010
2011 static LRESULT
2012 MultiInputDialog( HINSTANCE hinst, HWND hwndOwner,
2013                   char * ptext[], int numlines, int width,
2014                   int tb_cnt, struct textField * tb)
2015 {
2016     HGLOBAL hgbl;
2017     LPDLGTEMPLATE lpdt;
2018     LPDLGITEMTEMPLATE lpdit;
2019     LPWORD lpw;
2020     LPWSTR lpwsz;
2021     LRESULT ret;
2022     int nchar, i, pwid;
2023
2024     hgbl = GlobalAlloc(GMEM_ZEROINIT, 4096);
2025     if (!hgbl)
2026         return -1;
2027
2028     mid_cnt = tb_cnt;
2029     mid_tb = tb;
2030
2031     lpdt = (LPDLGTEMPLATE)GlobalLock(hgbl);
2032
2033     // Define a dialog box.
2034
2035     lpdt->style = WS_POPUP | WS_BORDER | WS_SYSMENU
2036                    | DS_MODALFRAME | WS_CAPTION | DS_CENTER
2037                    | DS_SETFOREGROUND | DS_3DLOOK
2038                    | DS_SETFONT | DS_FIXEDSYS | DS_NOFAILCREATE;
2039     lpdt->cdit = numlines + (2 * tb_cnt) + 2;  // number of controls
2040     lpdt->x  = 10;
2041     lpdt->y  = 10;
2042     lpdt->cx = 20 + width * 4;
2043     lpdt->cy = 20 + (numlines + tb_cnt + 4) * 14;
2044
2045     lpw = (LPWORD) (lpdt + 1);
2046     *lpw++ = 0;   // no menu
2047     *lpw++ = 0;   // predefined dialog box class (by default)
2048
2049     lpwsz = (LPWSTR) lpw;
2050     nchar = MultiByteToWideChar (CP_ACP, 0, "", -1, lpwsz, 128);
2051     lpw   += nchar;
2052     *lpw++ = 8;                        // font size (points)
2053     lpwsz = (LPWSTR) lpw;
2054     nchar = MultiByteToWideChar (CP_ACP, 0, "MS Shell Dlg",
2055                                     -1, lpwsz, 128);
2056     lpw   += nchar;
2057
2058     //-----------------------
2059     // Define an OK button.
2060     //-----------------------
2061     lpw = lpwAlign (lpw); // align DLGITEMTEMPLATE on DWORD boundary
2062     lpdit = (LPDLGITEMTEMPLATE) lpw;
2063     lpdit->style = WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON | WS_TABSTOP | WS_BORDER;
2064     lpdit->dwExtendedStyle = 0;
2065     lpdit->x  = (lpdt->cx - 14)/4 - 20;
2066     lpdit->y  = 10 + (numlines + tb_cnt + 2) * 14;
2067     lpdit->cx = 40;
2068     lpdit->cy = 14;
2069     lpdit->id = IDOK;  // OK button identifier
2070
2071     lpw = (LPWORD) (lpdit + 1);
2072     *lpw++ = 0xFFFF;
2073     *lpw++ = 0x0080;    // button class
2074
2075     lpwsz = (LPWSTR) lpw;
2076     nchar = MultiByteToWideChar (CP_ACP, 0, "OK", -1, lpwsz, 50);
2077     lpw   += nchar;
2078     *lpw++ = 0;           // no creation data
2079
2080     //-----------------------
2081     // Define an Cancel button.
2082     //-----------------------
2083     lpw = lpwAlign (lpw); // align DLGITEMTEMPLATE on DWORD boundary
2084     lpdit = (LPDLGITEMTEMPLATE) lpw;
2085     lpdit->style = WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP | WS_BORDER;
2086     lpdit->dwExtendedStyle = 0;
2087     lpdit->x  = (lpdt->cx - 14)*3/4 - 20;
2088     lpdit->y  = 10 + (numlines + tb_cnt + 2) * 14;
2089     lpdit->cx = 40;
2090     lpdit->cy = 14;
2091     lpdit->id = IDCANCEL;  // CANCEL button identifier
2092
2093     lpw = (LPWORD) (lpdit + 1);
2094     *lpw++ = 0xFFFF;
2095     *lpw++ = 0x0080;    // button class
2096
2097     lpwsz = (LPWSTR) lpw;
2098     nchar = MultiByteToWideChar (CP_ACP, 0, "Cancel", -1, lpwsz, 50);
2099     lpw   += nchar;
2100     *lpw++ = 0;           // no creation data
2101
2102     /* Add controls for preface data */
2103     for ( i=0; i<numlines; i++) {
2104         /*-----------------------
2105          * Define a static text control.
2106          *-----------------------*/
2107         lpw = lpwAlign (lpw); /* align DLGITEMTEMPLATE on DWORD boundary */
2108         lpdit = (LPDLGITEMTEMPLATE) lpw;
2109         lpdit->style = WS_CHILD | WS_VISIBLE | SS_LEFT;
2110         lpdit->dwExtendedStyle = 0;
2111         lpdit->x  = 10;
2112         lpdit->y  = 10 + i * 14;
2113         lpdit->cx = strlen(ptext[i]) * 4 + 10;
2114         lpdit->cy = 14;
2115         lpdit->id = ID_TEXT + i;  // text identifier
2116
2117         lpw = (LPWORD) (lpdit + 1);
2118         *lpw++ = 0xFFFF;
2119         *lpw++ = 0x0082;                         // static class
2120
2121         lpwsz = (LPWSTR) lpw;
2122         nchar = MultiByteToWideChar (CP_ACP, 0, ptext[i],
2123                                          -1, lpwsz, 2*width);
2124         lpw   += nchar;
2125         *lpw++ = 0;           // no creation data
2126     }
2127
2128     for ( i=0, pwid = 0; i<tb_cnt; i++) {
2129         if ( pwid < strlen(tb[i].label) )
2130             pwid = strlen(tb[i].label);
2131     }
2132
2133     for ( i=0; i<tb_cnt; i++) {
2134         /* Prompt */
2135         /*-----------------------
2136          * Define a static text control.
2137          *-----------------------*/
2138         lpw = lpwAlign (lpw); /* align DLGITEMTEMPLATE on DWORD boundary */
2139         lpdit = (LPDLGITEMTEMPLATE) lpw;
2140         lpdit->style = WS_CHILD | WS_VISIBLE | SS_LEFT;
2141         lpdit->dwExtendedStyle = 0;
2142         lpdit->x  = 10;
2143         lpdit->y  = 10 + (numlines + i + 1) * 14;
2144         lpdit->cx = pwid * 4;
2145         lpdit->cy = 14;
2146         lpdit->id = ID_TEXT + numlines + i;  // text identifier
2147
2148         lpw = (LPWORD) (lpdit + 1);
2149         *lpw++ = 0xFFFF;
2150         *lpw++ = 0x0082;                         // static class
2151
2152         lpwsz = (LPWSTR) lpw;
2153         nchar = MultiByteToWideChar (CP_ACP, 0, tb[i].label ? tb[i].label : "",
2154                                      -1, lpwsz, 128);
2155         lpw   += nchar;
2156         *lpw++ = 0;           // no creation data
2157
2158         /*-----------------------
2159          * Define an edit control.
2160          *-----------------------*/
2161         lpw = lpwAlign (lpw); /* align DLGITEMTEMPLATE on DWORD boundary */
2162         lpdit = (LPDLGITEMTEMPLATE) lpw;
2163         lpdit->style = WS_CHILD | WS_VISIBLE | ES_LEFT | WS_TABSTOP | WS_BORDER | (tb[i].echo == 1 ? 0L : ES_PASSWORD);
2164         lpdit->dwExtendedStyle = 0;
2165         lpdit->x  = 10 + (pwid + 1) * 4;
2166         lpdit->y  = 10 + (numlines + i + 1) * 14;
2167         lpdit->cx = (width - (pwid + 1)) * 4;
2168         lpdit->cy = 14;
2169         lpdit->id = ID_MID_TEXT + i;             // identifier
2170
2171         lpw = (LPWORD) (lpdit + 1);
2172         *lpw++ = 0xFFFF;
2173         *lpw++ = 0x0081;                         // edit class
2174
2175         lpwsz = (LPWSTR) lpw;
2176         nchar = MultiByteToWideChar (CP_ACP, 0, tb[i].def ? tb[i].def : "",
2177                                      -1, lpwsz, 128);
2178         lpw   += nchar;
2179         *lpw++ = 0;           // no creation data
2180     }
2181
2182     GlobalUnlock(hgbl);
2183     ret = DialogBoxIndirect(hinst, (LPDLGTEMPLATE) hgbl,
2184                                                         hwndOwner, (DLGPROC) MultiInputDialogProc);
2185     GlobalFree(hgbl);
2186
2187     switch ( ret ) {
2188     case 0:     /* Timeout */
2189         return -1;
2190     case IDOK:
2191         return 1;
2192     case IDCANCEL:
2193         return 0;
2194     default: {
2195         char buf[256];
2196         sprintf(buf,"DialogBoxIndirect() failed: %d",GetLastError());
2197         MessageBox(hwndOwner,
2198                     buf,
2199                     "GetLastError()",
2200                     MB_OK | MB_ICONINFORMATION | MB_TASKMODAL);
2201         return -1;
2202     }
2203     }
2204 }
2205
2206 static int
2207 multi_field_dialog(HWND hParent, char * preface, int n, struct textField tb[])
2208 {
2209         HINSTANCE hInst = 0;
2210     int maxwidth = 0;
2211     int numlines = 0;
2212     int len;
2213     char * plines[16], *p = preface ? preface : "";
2214     int i;
2215
2216     for ( i=0; i<16; i++ )
2217         plines[i] = NULL;
2218
2219     while (*p && numlines < 16) {
2220         plines[numlines++] = p;
2221         for ( ;*p && *p != '\r' && *p != '\n'; p++ );
2222         if ( *p == '\r' && *(p+1) == '\n' ) {
2223             *p++ = '\0';
2224             p++;
2225         } else if ( *p == '\n' ) {
2226             *p++ = '\0';
2227         }
2228         if ( strlen(plines[numlines-1]) > maxwidth )
2229             maxwidth = strlen(plines[numlines-1]);
2230     }
2231
2232     for ( i=0;i<n;i++ ) {
2233         len = strlen(tb[i].label) + 1 + (tb[i].len > 40 ? 40 : tb[i].len);
2234         if ( maxwidth < len )
2235             maxwidth = len;
2236     }
2237
2238     return(MultiInputDialog(hInst, hParent, plines, numlines, maxwidth, n, tb));
2239 }
2240
2241 static krb5_error_code KRB5_CALLCONV
2242 KRB5_prompter( krb5_context context,
2243                void *data,
2244                const char *name,
2245                const char *banner,
2246                int num_prompts,
2247                krb5_prompt prompts[])
2248 {
2249     krb5_error_code     errcode = 0;
2250     int                 i;
2251     struct textField * tb = NULL;
2252     int    len = 0, blen=0, nlen=0;
2253         HWND hParent = (HWND)data;
2254
2255     if (name)
2256         nlen = strlen(name)+2;
2257
2258     if (banner)
2259         blen = strlen(banner)+2;
2260
2261     tb = (struct textField *) malloc(sizeof(struct textField) * num_prompts);
2262     if ( tb != NULL ) {
2263         int ok;
2264         memset(tb,0,sizeof(struct textField) * num_prompts);
2265         for ( i=0; i < num_prompts; i++ ) {
2266             tb[i].buf = prompts[i].reply->data;
2267             tb[i].len = prompts[i].reply->length;
2268             tb[i].label = prompts[i].prompt;
2269             tb[i].def = NULL;
2270             tb[i].echo = (prompts[i].hidden ? 2 : 1);
2271         }
2272
2273         ok = multi_field_dialog(hParent,(char *)banner,num_prompts,tb);
2274         if ( ok ) {
2275             for ( i=0; i < num_prompts; i++ )
2276                 prompts[i].reply->length = strlen(prompts[i].reply->data);
2277         } else
2278             errcode = -2;
2279     }
2280
2281     if ( tb )
2282         free(tb);
2283     if (errcode) {
2284         for (i = 0; i < num_prompts; i++) {
2285             memset(prompts[i].reply->data, 0, prompts[i].reply->length);
2286         }
2287     }
2288     return errcode;
2289 }
2290
2291 BOOL
2292 KFW_AFS_wait_for_service_start(void)
2293 {
2294     char    HostName[64];
2295     DWORD   CurrentState;
2296
2297     CurrentState = SERVICE_START_PENDING;
2298     memset(HostName, '\0', sizeof(HostName));
2299     gethostname(HostName, sizeof(HostName));
2300
2301     while (CurrentState != SERVICE_RUNNING || CurrentState != SERVICE_STOPPED)
2302     {
2303         if (GetServiceStatus(HostName, TRANSARCAFSDAEMON, &CurrentState) != NOERROR)
2304             return(0);
2305         if ( IsDebuggerPresent() ) {
2306             switch ( CurrentState ) {
2307             case SERVICE_STOPPED:
2308                 OutputDebugString("SERVICE_STOPPED\n");
2309                 break;
2310             case SERVICE_START_PENDING:
2311                 OutputDebugString("SERVICE_START_PENDING\n");
2312                 break;
2313             case SERVICE_STOP_PENDING:
2314                 OutputDebugString("SERVICE_STOP_PENDING\n");
2315                 break;
2316             case SERVICE_RUNNING:
2317                 OutputDebugString("SERVICE_RUNNING\n");
2318                 break;
2319             case SERVICE_CONTINUE_PENDING:
2320                 OutputDebugString("SERVICE_CONTINUE_PENDING\n");
2321                 break;
2322             case SERVICE_PAUSE_PENDING:
2323                 OutputDebugString("SERVICE_PAUSE_PENDING\n");
2324                 break;
2325             case SERVICE_PAUSED:
2326                 OutputDebugString("SERVICE_PAUSED\n");
2327                 break;
2328             default:
2329                 OutputDebugString("UNKNOWN Service State\n");
2330             }
2331         }
2332         if (CurrentState == SERVICE_STOPPED)
2333             return(0);
2334         if (CurrentState == SERVICE_RUNNING)
2335             return(1);
2336         Sleep(500);
2337     }
2338     return(0);
2339 }
2340
2341
2342 int
2343 KFW_AFS_unlog(void)
2344 {
2345     long        rc;
2346     char    HostName[64];
2347     DWORD   CurrentState;
2348
2349     CurrentState = 0;
2350     memset(HostName, '\0', sizeof(HostName));
2351     gethostname(HostName, sizeof(HostName));
2352     if (GetServiceStatus(HostName, TRANSARCAFSDAEMON, &CurrentState) != NOERROR)
2353         return(0);
2354     if (CurrentState != SERVICE_RUNNING)
2355         return(0);
2356
2357     rc = ktc_ForgetAllTokens();
2358
2359     return(0);
2360 }
2361
2362 int
2363 KFW_AFS_klog(
2364     krb5_context alt_ctx,
2365     krb5_ccache  alt_cc,
2366     char *service,
2367     char *cell,
2368     char *realm,
2369     int LifeTime,
2370     char *smbname
2371     )
2372 {
2373     long        rc = 0;
2374     CREDENTIALS creds;
2375     KTEXT_ST    ticket;
2376     struct ktc_principal        aserver;
2377     struct ktc_principal        aclient;
2378     char        realm_of_user[REALM_SZ]; /* Kerberos realm of user */
2379     char        realm_of_cell[REALM_SZ]; /* Kerberos realm of cell */
2380     char        local_cell[MAXCELLCHARS+1];
2381     char        Dmycell[MAXCELLCHARS+1];
2382     struct ktc_token    atoken;
2383     struct ktc_token    btoken;
2384     struct afsconf_cell ak_cellconfig; /* General information about the cell */
2385     char        RealmName[128];
2386     char        CellName[128];
2387     char        ServiceName[128];
2388     DWORD       CurrentState;
2389     char        HostName[64];
2390     BOOL        try_krb5 = 0;
2391     krb5_context  ctx = 0;
2392     krb5_ccache   cc = 0;
2393     krb5_creds increds;
2394     krb5_creds * k5creds = 0;
2395     krb5_error_code code;
2396     krb5_principal client_principal = 0;
2397     int i, retry = 0;
2398
2399     CurrentState = 0;
2400     memset(HostName, '\0', sizeof(HostName));
2401     gethostname(HostName, sizeof(HostName));
2402     if (GetServiceStatus(HostName, TRANSARCAFSDAEMON, &CurrentState) != NOERROR) {
2403         if ( IsDebuggerPresent() )
2404             OutputDebugString("Unable to retrieve AFSD Service Status\n");
2405         return(-1);
2406     }
2407     if (CurrentState != SERVICE_RUNNING) {
2408         if ( IsDebuggerPresent() )
2409             OutputDebugString("AFSD Service NOT RUNNING\n");
2410         return(-2);
2411     }
2412
2413     if (!pkrb5_init_context)
2414         return 0;
2415
2416     memset(RealmName, '\0', sizeof(RealmName));
2417     memset(CellName, '\0', sizeof(CellName));
2418     memset(ServiceName, '\0', sizeof(ServiceName));
2419     memset(realm_of_user, '\0', sizeof(realm_of_user));
2420     memset(realm_of_cell, '\0', sizeof(realm_of_cell));
2421         if (cell && cell[0])
2422                 strcpy(Dmycell, cell);
2423         else
2424                 memset(Dmycell, '\0', sizeof(Dmycell));
2425
2426     // NULL or empty cell returns information on local cell
2427     if (rc = KFW_AFS_get_cellconfig(Dmycell, &ak_cellconfig, local_cell))
2428     {
2429         // KFW_AFS_error(rc, "get_cellconfig()");
2430         return(rc);
2431     }
2432
2433     if ( alt_ctx ) {
2434         ctx = alt_ctx;
2435     } else {
2436         code = pkrb5_init_context(&ctx);
2437         if (code) goto cleanup;
2438     }
2439
2440     if ( alt_cc ) {
2441         cc = alt_cc;
2442     } else {
2443         code = pkrb5_cc_default(ctx, &cc);
2444         if (code) goto skip_krb5_init;
2445     }
2446
2447     memset((char *)&increds, 0, sizeof(increds));
2448
2449     code = pkrb5_cc_get_principal(ctx, cc, &client_principal);
2450         if (code) {
2451         if ( code == KRB5_CC_NOTFOUND && IsDebuggerPresent() )
2452         {
2453             OutputDebugString("Principal Not Found for ccache\n");
2454         }
2455         goto skip_krb5_init;
2456     }
2457     i = krb5_princ_realm(ctx, client_principal)->length;
2458     if (i > REALM_SZ-1)
2459         i = REALM_SZ-1;
2460     strncpy(realm_of_user,krb5_princ_realm(ctx, client_principal)->data,i);
2461     realm_of_user[i] = 0;
2462     try_krb5 = 1;
2463
2464   skip_krb5_init:
2465 #ifdef USE_KRB4
2466     if ( !try_krb5 || !realm_of_user[0] ) {
2467         if ((rc = (*pkrb_get_tf_realm)((*ptkt_string)(), realm_of_user)) != KSUCCESS)
2468         {
2469             goto cleanup;
2470         }
2471     }
2472 #else
2473     goto cleanup;
2474 #endif
2475     strcpy(realm_of_cell, afs_realm_of_cell(&ak_cellconfig));
2476
2477     if (strlen(service) == 0)
2478         strcpy(ServiceName, "afs");
2479     else
2480         strcpy(ServiceName, service);
2481
2482     if (strlen(cell) == 0)
2483         strcpy(CellName, local_cell);
2484     else
2485         strcpy(CellName, cell);
2486
2487     if (strlen(realm) == 0)
2488         strcpy(RealmName, realm_of_cell);
2489     else
2490         strcpy(RealmName, realm);
2491
2492     memset(&creds, '\0', sizeof(creds));
2493
2494     if ( try_krb5 ) {
2495         int len;
2496
2497         /* First try service/cell@REALM */
2498         if (code = pkrb5_build_principal(ctx, &increds.server,
2499                                           strlen(RealmName),
2500                                           RealmName,
2501                                           ServiceName,
2502                                           CellName,
2503                                           0))
2504         {
2505             goto cleanup;
2506         }
2507
2508         increds.client = client_principal;
2509         increds.times.endtime = 0;
2510         /* Ask for DES since that is what V4 understands */
2511         increds.keyblock.enctype = ENCTYPE_DES_CBC_CRC;
2512
2513
2514         if ( IsDebuggerPresent() ) {
2515             char * cname, *sname;
2516             pkrb5_unparse_name(ctx, increds.client, &cname);
2517             pkrb5_unparse_name(ctx, increds.server, &sname);
2518             OutputDebugString("Getting tickets for \"");
2519             OutputDebugString(cname);
2520             OutputDebugString("\" and service \"");
2521             OutputDebugString(sname);
2522             OutputDebugString("\"\n");
2523             pkrb5_free_unparsed_name(ctx,cname);
2524             pkrb5_free_unparsed_name(ctx,sname);
2525         }
2526
2527         code = pkrb5_get_credentials(ctx, 0, cc, &increds, &k5creds);
2528         if (code == KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN ||
2529              code == KRB5KRB_ERR_GENERIC /* heimdal */ ||
2530                          code == KRB5KRB_AP_ERR_MSG_TYPE) {
2531             /* Or service@REALM */
2532             pkrb5_free_principal(ctx,increds.server);
2533             increds.server = 0;
2534             code = pkrb5_build_principal(ctx, &increds.server,
2535                                           strlen(RealmName),
2536                                           RealmName,
2537                                           ServiceName,
2538                                           0);
2539
2540             if ( IsDebuggerPresent() ) {
2541                 char * cname, *sname;
2542                 pkrb5_unparse_name(ctx, increds.client, &cname);
2543                 pkrb5_unparse_name(ctx, increds.server, &sname);
2544                 OutputDebugString("krb5_get_credentials() returned Service Principal Unknown\n");
2545                 OutputDebugString("Trying again: getting tickets for \"");
2546                 OutputDebugString(cname);
2547                 OutputDebugString("\" and service \"");
2548                 OutputDebugString(sname);
2549                 OutputDebugString("\"\n");
2550                 pkrb5_free_unparsed_name(ctx,cname);
2551                 pkrb5_free_unparsed_name(ctx,sname);
2552             }
2553
2554             if (!code)
2555                 code = pkrb5_get_credentials(ctx, 0, cc, &increds, &k5creds);
2556         }
2557
2558         if ((code == KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN ||
2559               code == KRB5KRB_ERR_GENERIC /* heimdal */ ||
2560                           code == KRB5KRB_AP_ERR_MSG_TYPE) &&
2561              strcmp(RealmName, realm_of_cell)) {
2562             /* Or service/cell@REALM_OF_CELL */
2563             strcpy(RealmName, realm_of_cell);
2564             pkrb5_free_principal(ctx,increds.server);
2565             increds.server = 0;
2566             code = pkrb5_build_principal(ctx, &increds.server,
2567                                          strlen(RealmName),
2568                                          RealmName,
2569                                          ServiceName,
2570                                          CellName,
2571                                          0);
2572
2573             if ( IsDebuggerPresent() ) {
2574                 char * cname, *sname;
2575                 pkrb5_unparse_name(ctx, increds.client, &cname);
2576                 pkrb5_unparse_name(ctx, increds.server, &sname);
2577                 OutputDebugString("krb5_get_credentials() returned Service Principal Unknown\n");
2578                 OutputDebugString("Trying again: getting tickets for \"");
2579                 OutputDebugString(cname);
2580                 OutputDebugString("\" and service \"");
2581                 OutputDebugString(sname);
2582                 OutputDebugString("\"\n");
2583                 pkrb5_free_unparsed_name(ctx,cname);
2584                 pkrb5_free_unparsed_name(ctx,sname);
2585             }
2586
2587             if (!code)
2588                 code = pkrb5_get_credentials(ctx, 0, cc, &increds, &k5creds);
2589
2590
2591             if (code == KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN ||
2592                  code == KRB5KRB_ERR_GENERIC /* heimdal */ ||
2593                                  code == KRB5KRB_AP_ERR_MSG_TYPE) {
2594                 /* Or service@REALM_OF_CELL */
2595                 pkrb5_free_principal(ctx,increds.server);
2596                 increds.server = 0;
2597                 code = pkrb5_build_principal(ctx, &increds.server,
2598                                               strlen(RealmName),
2599                                               RealmName,
2600                                               ServiceName,
2601                                               0);
2602
2603                 if ( IsDebuggerPresent() ) {
2604                     char * cname, *sname;
2605                     pkrb5_unparse_name(ctx, increds.client, &cname);
2606                     pkrb5_unparse_name(ctx, increds.server, &sname);
2607                     OutputDebugString("krb5_get_credentials() returned Service Principal Unknown\n");
2608                     OutputDebugString("Trying again: getting tickets for \"");
2609                     OutputDebugString(cname);
2610                     OutputDebugString("\" and service \"");
2611                     OutputDebugString(sname);
2612                     OutputDebugString("\"\n");
2613                     pkrb5_free_unparsed_name(ctx,cname);
2614                     pkrb5_free_unparsed_name(ctx,sname);
2615                 }
2616
2617                 if (!code)
2618                     code = pkrb5_get_credentials(ctx, 0, cc, &increds, &k5creds);
2619             }
2620         }
2621
2622         if (code) {
2623             if ( IsDebuggerPresent() ) {
2624                 char message[256];
2625                 sprintf(message,"krb5_get_credentials returns: %d\n",code);
2626                 OutputDebugString(message);
2627             }
2628             try_krb5 = 0;
2629             goto use_krb4;
2630         }
2631
2632         /* This code inserts the entire K5 ticket into the token
2633          * No need to perform a krb524 translation which is
2634          * commented out in the code below
2635          */
2636         if (k5creds->ticket.length > MAXKTCTICKETLEN)
2637             goto try_krb524d;
2638
2639         memset(&aserver, '\0', sizeof(aserver));
2640         strncpy(aserver.name, ServiceName, MAXKTCNAMELEN - 1);
2641         strncpy(aserver.cell, CellName, MAXKTCREALMLEN - 1);
2642
2643         memset(&atoken, '\0', sizeof(atoken));
2644         atoken.kvno = RXKAD_TKT_TYPE_KERBEROS_V5;
2645         atoken.startTime = k5creds->times.starttime;
2646         atoken.endTime = k5creds->times.endtime;
2647         memcpy(&atoken.sessionKey, k5creds->keyblock.contents, k5creds->keyblock.length);
2648         atoken.ticketLen = k5creds->ticket.length;
2649         memcpy(atoken.ticket, k5creds->ticket.data, atoken.ticketLen);
2650
2651       retry_gettoken5:
2652         rc = ktc_GetToken(&aserver, &btoken, sizeof(btoken), &aclient);
2653         if (rc != 0 && rc != KTC_NOENT && rc != KTC_NOCELL) {
2654             if ( rc == KTC_NOCM && retry < 20 ) {
2655                 Sleep(500);
2656                 retry++;
2657                 goto retry_gettoken5;
2658             }
2659             goto try_krb524d;
2660         }
2661
2662         if (atoken.kvno == btoken.kvno &&
2663              atoken.ticketLen == btoken.ticketLen &&
2664              !memcmp(&atoken.sessionKey, &btoken.sessionKey, sizeof(atoken.sessionKey)) &&
2665              !memcmp(atoken.ticket, btoken.ticket, atoken.ticketLen))
2666         {
2667             /* Success - Nothing to do */
2668             goto cleanup;
2669         }
2670
2671         // * Reset the "aclient" structure before we call ktc_SetToken.
2672         // * This structure was first set by the ktc_GetToken call when
2673         // * we were comparing whether identical tokens already existed.
2674
2675         len = min(k5creds->client->data[0].length,MAXKTCNAMELEN - 1);
2676         strncpy(aclient.name, k5creds->client->data[0].data, len);
2677         aclient.name[len] = '\0';
2678
2679         if ( k5creds->client->length > 1 ) {
2680             char * p;
2681             strcat(aclient.name, ".");
2682             p = aclient.name + strlen(aclient.name);
2683             len = min(k5creds->client->data[1].length,MAXKTCNAMELEN - strlen(aclient.name) - 1);
2684             strncpy(p, k5creds->client->data[1].data, len);
2685             p[len] = '\0';
2686         }
2687         aclient.instance[0] = '\0';
2688
2689         strcpy(aclient.cell, realm_of_cell);
2690
2691         len = min(k5creds->client->realm.length,strlen(realm_of_cell));
2692         if ( strncmp(realm_of_cell, k5creds->client->realm.data, len) ) {
2693             char * p;
2694             strcat(aclient.name, "@");
2695             p = aclient.name + strlen(aclient.name);
2696             len = min(k5creds->client->realm.length,MAXKTCNAMELEN - strlen(aclient.name) - 1);
2697             strncpy(p, k5creds->client->realm.data, len);
2698             p[len] = '\0';
2699         }
2700
2701         if ( smbname ) {
2702             strncpy(aclient.smbname, smbname, MAXRANDOMNAMELEN);
2703             aclient.smbname[MAXRANDOMNAMELEN-1] = '\0';
2704         } else {
2705             aclient.smbname[0] = '\0';
2706         }
2707
2708         rc = ktc_SetToken(&aserver, &atoken, &aclient, 0);
2709         if (!rc)
2710             goto cleanup;   /* We have successfully inserted the token */
2711
2712       try_krb524d:
2713         /* Otherwise, the ticket could have been too large so try to
2714          * convert using the krb524d running with the KDC
2715          */
2716         code = pkrb524_convert_creds_kdc(ctx, k5creds, &creds);
2717         pkrb5_free_creds(ctx, k5creds);
2718         if (code) {
2719             if ( IsDebuggerPresent() ) {
2720                 char message[256];
2721                 sprintf(message,"krb524_convert_creds_kdc returns: %d\n",code);
2722                 OutputDebugString(message);
2723             }
2724             try_krb5 = 0;
2725             goto use_krb4;
2726         }
2727     } else {
2728       use_krb4:
2729 #ifdef USE_KRB4
2730         code = (*pkrb_get_cred)(ServiceName, CellName, RealmName, &creds);
2731         if (code == NO_TKT_FIL) {
2732             // if the problem is that we have no krb4 tickets
2733             // do not attempt to continue
2734             goto cleanup;
2735         }
2736         if (code != KSUCCESS)
2737             code = (*pkrb_get_cred)(ServiceName, "", RealmName, &creds);
2738
2739         if (code != KSUCCESS)
2740         {
2741             if ((code = (*pkrb_mk_req)(&ticket, ServiceName, CellName, RealmName, 0)) == KSUCCESS)
2742             {
2743                 if ((code = (*pkrb_get_cred)(ServiceName, CellName, RealmName, &creds)) != KSUCCESS)
2744                 {
2745                     goto cleanup;
2746                 }
2747             }
2748             else if ((code = (*pkrb_mk_req)(&ticket, ServiceName, "", RealmName, 0)) == KSUCCESS)
2749             {
2750                 if ((code = (*pkrb_get_cred)(ServiceName, "", RealmName, &creds)) != KSUCCESS)
2751                 {
2752                     goto cleanup;
2753                 }
2754             }
2755             else
2756             {
2757                 goto cleanup;
2758             }
2759         }
2760 #else
2761         goto cleanup;
2762 #endif
2763     }
2764
2765     memset(&aserver, '\0', sizeof(aserver));
2766     strncpy(aserver.name, ServiceName, MAXKTCNAMELEN - 1);
2767     strncpy(aserver.cell, CellName, MAXKTCREALMLEN - 1);
2768
2769     memset(&atoken, '\0', sizeof(atoken));
2770     atoken.kvno = creds.kvno;
2771     atoken.startTime = creds.issue_date;
2772     atoken.endTime = creds.issue_date + life_to_time(0,creds.lifetime);
2773     memcpy(&atoken.sessionKey, creds.session, 8);
2774     atoken.ticketLen = creds.ticket_st.length;
2775     memcpy(atoken.ticket, creds.ticket_st.dat, atoken.ticketLen);
2776
2777   retry_gettoken:
2778     rc = ktc_GetToken(&aserver, &btoken, sizeof(btoken), &aclient);
2779     if (rc != 0 && rc != KTC_NOENT && rc != KTC_NOCELL) {
2780         if ( rc == KTC_NOCM && retry < 20 ) {
2781             Sleep(500);
2782             retry++;
2783             goto retry_gettoken;
2784         }
2785         KFW_AFS_error(rc, "ktc_GetToken()");
2786         code = rc;
2787         goto cleanup;
2788     }
2789
2790     if (atoken.kvno == btoken.kvno &&
2791         atoken.ticketLen == btoken.ticketLen &&
2792         !memcmp(&atoken.sessionKey, &btoken.sessionKey, sizeof(atoken.sessionKey)) &&
2793         !memcmp(atoken.ticket, btoken.ticket, atoken.ticketLen))
2794     {
2795         goto cleanup;
2796     }
2797
2798     // * Reset the "aclient" structure before we call ktc_SetToken.
2799     // * This structure was first set by the ktc_GetToken call when
2800     // * we were comparing whether identical tokens already existed.
2801
2802     strncpy(aclient.name, creds.pname, MAXKTCNAMELEN - 1);
2803     if (creds.pinst[0])
2804     {
2805         strncat(aclient.name, ".", MAXKTCNAMELEN - 1);
2806         strncat(aclient.name, creds.pinst, MAXKTCNAMELEN - 1);
2807     }
2808     strcpy(aclient.instance, "");
2809
2810     if ( strcmp(realm_of_cell, creds.realm) )
2811     {
2812         strncat(aclient.name, "@", MAXKTCNAMELEN - 1);
2813         strncpy(aclient.name, creds.realm, MAXKTCREALMLEN - 1);
2814     }
2815     aclient.name[MAXKTCREALMLEN-1] = '\0';
2816
2817     strcpy(aclient.cell, CellName);
2818
2819     if ( smbname ) {
2820         strncpy(aclient.smbname, smbname, MAXRANDOMNAMELEN);
2821         aclient.smbname[MAXRANDOMNAMELEN-1] = '\0';
2822     } else {
2823         aclient.smbname[0] = '\0';
2824     }
2825
2826     if (rc = ktc_SetToken(&aserver, &atoken, &aclient, 0))
2827     {
2828         KFW_AFS_error(rc, "ktc_SetToken()");
2829         code = rc;
2830         goto cleanup;
2831     }
2832
2833   cleanup:
2834     if (client_principal)
2835         pkrb5_free_principal(ctx,client_principal);
2836     /* increds.client == client_principal */
2837     if (increds.server)
2838         pkrb5_free_principal(ctx,increds.server);
2839     if (cc && (cc != alt_cc))
2840         pkrb5_cc_close(ctx, cc);
2841     if (ctx && (ctx != alt_ctx))
2842         pkrb5_free_context(ctx);
2843
2844         return(rc? rc : code);
2845 }
2846
2847 /**************************************/
2848 /* afs_realm_of_cell():               */
2849 /**************************************/
2850 static char *
2851 afs_realm_of_cell(struct afsconf_cell *cellconfig)
2852 {
2853     static char krbrlm[REALM_SZ+1]="";
2854     krb5_context  ctx = 0;
2855     char ** realmlist=NULL;
2856     krb5_error_code r;
2857
2858     if (!cellconfig)
2859         return 0;
2860
2861     if (!pkrb5_init_context)
2862         return 0;
2863
2864     r = pkrb5_init_context(&ctx);
2865     if ( !r )
2866         r = pkrb5_get_host_realm(ctx, cellconfig->hostName[0], &realmlist);
2867     if ( !r && realmlist && realmlist[0] ) {
2868         strcpy(krbrlm, realmlist[0]);
2869         pkrb5_free_host_realm(ctx, realmlist);
2870     }
2871     if (ctx)
2872         pkrb5_free_context(ctx);
2873
2874     if ( !krbrlm[0] )
2875     {
2876         char *s = krbrlm;
2877         char *t = cellconfig->name;
2878         int c;
2879
2880         while (c = *t++)
2881         {
2882             if (islower(c)) c=toupper(c);
2883             *s++ = c;
2884         }
2885         *s++ = 0;
2886     }
2887     return(krbrlm);
2888 }
2889
2890 /**************************************/
2891 /* KFW_AFS_get_cellconfig():          */
2892 /**************************************/
2893 int
2894 KFW_AFS_get_cellconfig(char *cell, struct afsconf_cell *cellconfig, char *local_cell)
2895 {
2896     int rc;
2897     char newcell[MAXCELLCHARS+1];
2898
2899     local_cell[0] = (char)0;
2900     memset(cellconfig, 0, sizeof(*cellconfig));
2901
2902     /* WIN32: cm_GetRootCellName(local_cell) - NOTE: no way to get max chars */
2903     if (rc = cm_GetRootCellName(local_cell))
2904     {
2905         return(rc);
2906     }
2907
2908     if (strlen(cell) == 0)
2909         strcpy(cell, local_cell);
2910
2911     /* WIN32: cm_SearchCellFile(cell, pcallback, pdata) */
2912     strcpy(cellconfig->name, cell);
2913
2914     rc = cm_SearchCellFile(cell, newcell, get_cellconfig_callback, (void*)cellconfig);
2915 #ifdef AFS_AFSDB_ENV
2916     if (rc != 0) {
2917         int ttl;
2918         rc = cm_SearchCellByDNS(cell, newcell, &ttl, get_cellconfig_callback, (void*)cellconfig);
2919     }
2920 #endif
2921     return rc;
2922 }
2923
2924 /**************************************/
2925 /* get_cellconfig_callback():         */
2926 /**************************************/
2927 static long
2928 get_cellconfig_callback(void *cellconfig, struct sockaddr_in *addrp, char *namep)
2929 {
2930     struct afsconf_cell *cc = (struct afsconf_cell *)cellconfig;
2931
2932     cc->hostAddr[cc->numServers] = *addrp;
2933     strcpy(cc->hostName[cc->numServers], namep);
2934     cc->numServers++;
2935     return(0);
2936 }
2937
2938
2939 /**************************************/
2940 /* KFW_AFS_error():                  */
2941 /**************************************/
2942 void
2943 KFW_AFS_error(LONG rc, LPCSTR FailedFunctionName)
2944 {
2945     char message[256];
2946     const char *errText;
2947
2948     // Using AFS defines as error messages for now, until Transarc
2949     // gets back to me with "string" translations of each of these
2950     // const. defines.
2951     if (rc == KTC_ERROR)
2952       errText = "KTC_ERROR";
2953     else if (rc == KTC_TOOBIG)
2954       errText = "KTC_TOOBIG";
2955     else if (rc == KTC_INVAL)
2956       errText = "KTC_INVAL";
2957     else if (rc == KTC_NOENT)
2958       errText = "KTC_NOENT";
2959     else if (rc == KTC_PIOCTLFAIL)
2960       errText = "KTC_PIOCTLFAIL";
2961     else if (rc == KTC_NOPIOCTL)
2962       errText = "KTC_NOPIOCTL";
2963     else if (rc == KTC_NOCELL)
2964       errText = "KTC_NOCELL";
2965     else if (rc == KTC_NOCM)
2966       errText = "KTC_NOCM: The service, Transarc AFS Daemon, most likely is not started!";
2967     else
2968       errText = "Unknown error!";
2969
2970     sprintf(message, "%s (0x%x)\n(%s failed)", errText, rc, FailedFunctionName);
2971
2972     if ( IsDebuggerPresent() ) {
2973         OutputDebugString(message);
2974         OutputDebugString("\n");
2975     }
2976     MessageBox(NULL, message, "AFS", MB_OK | MB_ICONERROR | MB_TASKMODAL | MB_SETFOREGROUND);
2977     return;
2978 }
2979
2980 static DWORD
2981 GetServiceStatus(
2982     LPSTR lpszMachineName,
2983     LPSTR lpszServiceName,
2984     DWORD *lpdwCurrentState)
2985 {
2986     DWORD           hr               = NOERROR;
2987     SC_HANDLE       schSCManager     = NULL;
2988     SC_HANDLE       schService       = NULL;
2989     DWORD           fdwDesiredAccess = 0;
2990     SERVICE_STATUS  ssServiceStatus  = {0};
2991     BOOL            fRet             = FALSE;
2992
2993     *lpdwCurrentState = 0;
2994
2995     fdwDesiredAccess = GENERIC_READ;
2996
2997     schSCManager = OpenSCManager(lpszMachineName,
2998                                  NULL,
2999                                  fdwDesiredAccess);
3000
3001     if(schSCManager == NULL)
3002     {
3003         hr = GetLastError();
3004         goto cleanup;
3005     }
3006
3007     schService = OpenService(schSCManager,
3008                              lpszServiceName,
3009                              fdwDesiredAccess);
3010
3011     if(schService == NULL)
3012     {
3013         hr = GetLastError();
3014         goto cleanup;
3015     }
3016
3017     fRet = QueryServiceStatus(schService,
3018                               &ssServiceStatus);
3019
3020     if(fRet == FALSE)
3021     {
3022         hr = GetLastError();
3023         goto cleanup;
3024     }
3025
3026     *lpdwCurrentState = ssServiceStatus.dwCurrentState;
3027
3028 cleanup:
3029
3030     CloseServiceHandle(schService);
3031     CloseServiceHandle(schSCManager);
3032
3033     return(hr);
3034 }
3035
3036 void
3037 UnloadFuncs(
3038     FUNC_INFO fi[],
3039     HINSTANCE h
3040     )
3041 {
3042     int n;
3043     if (fi)
3044         for (n = 0; fi[n].func_ptr_var; n++)
3045             *(fi[n].func_ptr_var) = 0;
3046     if (h) FreeLibrary(h);
3047 }
3048
3049 int
3050 LoadFuncs(
3051     const char* dll_name,
3052     FUNC_INFO fi[],
3053     HINSTANCE* ph,  // [out, optional] - DLL handle
3054     int* pindex,    // [out, optional] - index of last func loaded (-1 if none)
3055     int cleanup,    // cleanup function pointers and unload on error
3056     int go_on,      // continue loading even if some functions cannot be loaded
3057     int silent      // do not pop-up a system dialog if DLL cannot be loaded
3058     )
3059 {
3060     HINSTANCE h;
3061     int i, n, last_i;
3062     int error = 0;
3063     UINT em;
3064
3065     if (ph) *ph = 0;
3066     if (pindex) *pindex = -1;
3067
3068     for (n = 0; fi[n].func_ptr_var; n++)
3069         *(fi[n].func_ptr_var) = 0;
3070
3071     if (silent)
3072         em = SetErrorMode(SEM_FAILCRITICALERRORS);
3073     h = LoadLibrary(dll_name);
3074     if (silent)
3075         SetErrorMode(em);
3076
3077     if (!h)
3078         return 0;
3079
3080     last_i = -1;
3081     for (i = 0; (go_on || !error) && (i < n); i++)
3082     {
3083         void* p = (void*)GetProcAddress(h, fi[i].func_name);
3084         if (!p)
3085             error = 1;
3086         else
3087         {
3088             last_i = i;
3089             *(fi[i].func_ptr_var) = p;
3090         }
3091     }
3092     if (pindex) *pindex = last_i;
3093     if (error && cleanup && !go_on) {
3094         for (i = 0; i < n; i++) {
3095             *(fi[i].func_ptr_var) = 0;
3096         }
3097         FreeLibrary(h);
3098         return 0;
3099     }
3100     if (ph) *ph = h;
3101     if (error) return 0;
3102     return 1;
3103 }
3104
3105 BOOL KFW_probe_kdc(struct afsconf_cell * cellconfig)
3106 {
3107     krb5_context ctx = 0;
3108     krb5_ccache cc = 0;
3109     krb5_error_code code;
3110     krb5_data pwdata;
3111     const char * realm = 0;
3112     krb5_principal principal = 0;
3113     char * pname = 0;
3114     char   password[PROBE_PASSWORD_LEN+1];
3115     BOOL serverReachable = 0;
3116
3117     realm = afs_realm_of_cell(cellconfig);  // do not free
3118
3119     code = pkrb5_build_principal(ctx, &principal, strlen(realm),
3120                                   realm, PROBE_USERNAME, NULL, NULL);
3121     if ( code ) goto cleanup;
3122
3123     code = KFW_get_ccache(ctx, principal, &cc);
3124     if ( code ) goto cleanup;
3125
3126     code = pkrb5_unparse_name(ctx, principal, &pname);
3127     if ( code ) goto cleanup;
3128
3129     pwdata.data = password;
3130     pwdata.length = PROBE_PASSWORD_LEN;
3131     code = pkrb5_c_random_make_octets(ctx, &pwdata);
3132     if (code) {
3133         int i;
3134         for ( i=0 ; i<PROBE_PASSWORD_LEN ; i++ )
3135             password[i] = 'x';
3136     }
3137     password[PROBE_PASSWORD_LEN] = '\0';
3138
3139     code = KFW_kinit(NULL, NULL, HWND_DESKTOP,
3140                       pname,
3141                       password,
3142                       5,
3143                       0,
3144                       0,
3145                       0,
3146                       1,
3147                       0);
3148     switch ( code ) {
3149     case KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN:
3150     case KRB5KDC_ERR_CLIENT_REVOKED:
3151     case KRB5KDC_ERR_CLIENT_NOTYET:
3152     case KRB5KDC_ERR_PREAUTH_FAILED:
3153     case KRB5KDC_ERR_PREAUTH_REQUIRED:
3154     case KRB5KDC_ERR_PADATA_TYPE_NOSUPP:
3155         serverReachable = TRUE;
3156         break;
3157     default:
3158         serverReachable = FALSE;
3159     }
3160
3161   cleanup:
3162     if ( pname )
3163         pkrb5_free_unparsed_name(ctx,pname);
3164     if ( principal )
3165         pkrb5_free_principal(ctx,principal);
3166     if (cc)
3167         pkrb5_cc_close(ctx,cc);
3168     if (ctx)
3169         pkrb5_free_context(ctx);
3170
3171     return serverReachable;
3172 }
3173