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(krb5_context, 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 *  princ_realm;
 864     krb5_error_code code;
 865     char cell[128]="", realm[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     princ_realm = krb5_princ_realm(ctx, princ);
 891     for ( i=0; i<princ_realm->length; i++ ) {
 892                 realm[i] = princ_realm->data[i];
 893         cell[i] = tolower(princ_realm->data[i]);
 894     }
 895         cell[i] = '\0';
 896         realm[i] = '\0';
 897
 898     code = KFW_AFS_klog(ctx, cc, "afs", cell, realm, pLeash_get_default_lifetime(),NULL);
 899     if ( IsDebuggerPresent() ) {
 900         char message[256];
 901         sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
 902         OutputDebugString(message);
 903     }
 904     if ( code ) goto cleanup;
 905
 906     KFW_AFS_update_cell_princ_map(ctx, cell, pname, TRUE);
 907
 908   cleanup:
 909     if (pname)
 910         pkrb5_free_unparsed_name(ctx,pname);
 911     if (princ)
 912         pkrb5_free_principal(ctx,princ);
 913     if (cc)
 914         pkrb5_cc_close(ctx,cc);
 915     if (ctx)
 916         pkrb5_free_context(ctx);
 917 }
 918 #endif /* USE_MS2MIT */
 919
 920 // If there are existing MIT credentials, copy them to a new
 921 // ccache named after the principal
 922
 923 // Enumerate all existing MIT ccaches and construct entries
 924 // in the principal_ccache table
 925
 926 // Enumerate all existing AFS Tokens and construct entries
 927 // in the cell_principal table
 928 void
 929 KFW_import_ccache_data(void)
 930 {
 931     krb5_context ctx = 0;
 932     krb5_ccache  cc = 0;
 933     krb5_principal principal = 0;
 934     krb5_creds creds;
 935     krb5_error_code code;
 936     krb5_error_code cc_code;
 937     krb5_cc_cursor cur;
 938     apiCB * cc_ctx = 0;
 939     struct _infoNC ** pNCi = NULL;
 940     int i, j, flags;
 941
 942     if ( !pcc_initialize )
 943         return;
 944
 945     if ( IsDebuggerPresent() )
 946         OutputDebugString("KFW_import_ccache_data()\n");
 947
 948     code = pcc_initialize(&cc_ctx, CC_API_VER_2, NULL, NULL);
 949     if (code) goto cleanup;
 950
 951     code = pcc_get_NC_info(cc_ctx, &pNCi);
 952     if (code) goto cleanup;
 953
 954     code = pkrb5_init_context(&ctx);
 955     if (code) goto cleanup;
 956
 957     for ( i=0; pNCi[i]; i++ ) {
 958         if ( pNCi[i]->vers != CC_CRED_V5 )
 959             continue;
 960         if ( IsDebuggerPresent() ) {
 961             OutputDebugString("Principal: ");
 962             OutputDebugString(pNCi[i]->principal);
 963             OutputDebugString(" in ccache ");
 964             OutputDebugString(pNCi[i]->name);
 965             OutputDebugString("\n");
 966         }
 967         if ( strcmp(pNCi[i]->name,pNCi[i]->principal)
 968              && strcmp(pNCi[i]->name,LSA_CCNAME)
 969              ) {
 970             int found = 0;
 971             for ( j=0; pNCi[j]; j++ ) {
 972                 if (!strcmp(pNCi[j]->name,pNCi[i]->principal)) {
 973                     found = 1;
 974                     break;
 975                 }
 976             }
 977
 978             code = pkrb5_cc_resolve(ctx, pNCi[i]->principal, &cc);
 979             if (code) goto loop_cleanup;
 980
 981             if (!found) {
 982                 krb5_ccache oldcc = 0;
 983
 984                 if ( IsDebuggerPresent() )
 985                     OutputDebugString("copying ccache data to new ccache\n");
 986
 987                 code = pkrb5_parse_name(ctx, pNCi[i]->principal, &principal);
 988                 if (code) goto loop_cleanup;
 989                 code = pkrb5_cc_initialize(ctx, cc, principal);
 990                 if (code) goto loop_cleanup;
 991
 992                 code = pkrb5_cc_resolve(ctx, pNCi[i]->name, &oldcc);
 993                 if (code) goto loop_cleanup;
 994                 code = pkrb5_cc_copy_creds(ctx,oldcc,cc);
 995                 if (code) {
 996                     code = pkrb5_cc_close(ctx,cc);
 997                     cc = 0;
 998                     code = pkrb5_cc_close(ctx,oldcc);
 999                     cc = 0;
1000                     KRB5_error(code, "krb5_cc_copy_creds", 0, NULL, NULL);
1001                     continue;
1002                 }
1003                 code = pkrb5_cc_close(ctx,oldcc);
1004             }
1005         } else {
1006             code = pkrb5_cc_resolve(ctx, pNCi[i]->name, &cc);
1007             if (code) goto loop_cleanup;
1008         }
1009
1010         flags = 0;  // turn off OPENCLOSE mode
1011         code = pkrb5_cc_set_flags(ctx, cc, flags);
1012         if ( code ) goto cleanup;
1013
1014         KFW_AFS_update_princ_ccache_data(ctx, cc, !strcmp(pNCi[i]->name,LSA_CCNAME));
1015
1016         cc_code = pkrb5_cc_start_seq_get(ctx, cc, &cur);
1017
1018         while (!(cc_code = pkrb5_cc_next_cred(ctx, cc, &cur, &creds))) {
1019             krb5_data * sname = krb5_princ_name(ctx, creds.server);
1020             krb5_data * cell  = krb5_princ_component(ctx, creds.server, 1);
1021             krb5_data * realm = krb5_princ_realm(ctx, creds.server);
1022             if ( sname && cell && !strcmp("afs",sname->data) ) {
1023                 struct ktc_principal    aserver;
1024                 struct ktc_principal    aclient;
1025                 struct ktc_token        atoken;
1026                 int active = TRUE;
1027
1028                 if ( IsDebuggerPresent() )  {
1029                     OutputDebugString("Found AFS ticket: ");
1030                     OutputDebugString(sname->data);
1031                     if ( cell->data ) {
1032                         OutputDebugString("/");
1033                         OutputDebugString(cell->data);
1034                     }
1035                     OutputDebugString("@");
1036                     OutputDebugString(realm->data);
1037                     OutputDebugString("\n");
1038                 }
1039
1040                 memset(&aserver, '\0', sizeof(aserver));
1041                 strcpy(aserver.name, sname->data);
1042                 strcpy(aserver.cell, cell->data);
1043
1044                 code = ktc_GetToken(&aserver, &atoken, sizeof(atoken), &aclient);
1045                 if (!code) {
1046                     // Found a token in AFS Client Server which matches
1047                     char pname[128], *p, *q;
1048                     for ( p=pname, q=aclient.name; *q; p++, q++)
1049                         *p = *q;
1050                     for ( *p++ = '@', q=aclient.cell; *q; p++, q++)
1051                         *p = toupper(*q);
1052                     *p = '\0';
1053
1054                     if ( IsDebuggerPresent() )  {
1055                         OutputDebugString("Found AFS token: ");
1056                         OutputDebugString(pname);
1057                         OutputDebugString("\n");
1058                     }
1059
1060                     if ( strcmp(pname,pNCi[i]->principal)  )
1061                         active = FALSE;
1062                     KFW_AFS_update_cell_princ_map(ctx, cell->data, pNCi[i]->principal, active);
1063                 } else {
1064                     // Attempt to import it
1065                     KFW_AFS_update_cell_princ_map(ctx, cell->data, pNCi[i]->principal, active);
1066
1067                     if ( IsDebuggerPresent() )  {
1068                         OutputDebugString("Calling KFW_AFS_klog() to obtain token\n");
1069                     }
1070
1071                     code = KFW_AFS_klog(ctx, cc, "afs", cell->data, realm->data, pLeash_get_default_lifetime(),NULL);
1072                     if ( IsDebuggerPresent() ) {
1073                         char message[256];
1074                         sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1075                         OutputDebugString(message);
1076                     }
1077                 }
1078             } else if ( IsDebuggerPresent() ) {
1079                 OutputDebugString("Found ticket: ");
1080                 OutputDebugString(sname->data);
1081                 if ( cell && cell->data ) {
1082                     OutputDebugString("/");
1083                     OutputDebugString(cell->data);
1084                 }
1085                 OutputDebugString("@");
1086                 OutputDebugString(realm->data);
1087                 OutputDebugString("\n");
1088             }
1089             pkrb5_free_cred_contents(ctx, &creds);
1090         }
1091
1092         if (cc_code == KRB5_CC_END) {
1093             cc_code = pkrb5_cc_end_seq_get(ctx, cc, &cur);
1094             if (cc_code) goto loop_cleanup;
1095         }
1096
1097       loop_cleanup:
1098         flags = KRB5_TC_OPENCLOSE;  //turn on OPENCLOSE
1099         code = pkrb5_cc_set_flags(ctx, cc, flags);
1100         if (cc) {
1101             pkrb5_cc_close(ctx,cc);
1102             cc = 0;
1103         }
1104         if (principal) {
1105             pkrb5_free_principal(ctx,principal);
1106             principal = 0;
1107         }
1108     }
1109
1110   cleanup:
1111     if (ctx)
1112         pkrb5_free_context(ctx);
1113     if (pNCi)
1114         pcc_free_NC_info(cc_ctx, &pNCi);
1115     if (cc_ctx)
1116         pcc_shutdown(&cc_ctx);
1117 }
1118
1119
1120 int
1121 KFW_AFS_get_cred(char * username,
1122                   char * cell,
1123                   char * password,
1124                   int lifetime,
1125                   char * smbname,
1126                   char ** reasonP )
1127 {
1128     krb5_context ctx = 0;
1129     krb5_ccache cc = 0;
1130     char * realm = 0;
1131     char ** realmlist = 0;
1132     krb5_principal principal = 0;
1133     char * pname = 0;
1134     krb5_error_code code;
1135         char local_cell[MAXCELLCHARS+1];
1136     char **cells = NULL;
1137     int  cell_count=0;
1138     struct afsconf_cell cellconfig;
1139
1140     if (!pkrb5_init_context)
1141         return 0;
1142
1143     if ( IsDebuggerPresent() ) {
1144         OutputDebugString("KFW_AFS_get_cred for token ");
1145         OutputDebugString(username);
1146         OutputDebugString(" in cell ");
1147         OutputDebugString(cell);
1148         OutputDebugString("\n");
1149     }
1150
1151     code = pkrb5_init_context(&ctx);
1152     if ( code ) goto cleanup;
1153
1154     code = KFW_AFS_get_cellconfig( cell, (void*)&cellconfig, local_cell);
1155     if ( code ) goto cleanup;
1156
1157     realm = strchr(username,'@');
1158     if (realm) {
1159         *realm = '\0';
1160         realm++;
1161     }
1162     if ( !realm || !realm[0] )
1163         realm = afs_realm_of_cell(ctx, &cellconfig);  // do not free
1164
1165     if ( IsDebuggerPresent() ) {
1166         OutputDebugString("Realm: ");
1167         OutputDebugString(realm);
1168         OutputDebugString("\n");
1169     }
1170
1171     code = pkrb5_build_principal(ctx, &principal, strlen(realm),
1172                                  realm, username,
1173                                  NULL,
1174                                  NULL);
1175
1176     code = KFW_get_ccache(ctx, principal, &cc);
1177     if ( code ) goto cleanup;
1178
1179     code = pkrb5_unparse_name(ctx, principal, &pname);
1180     if ( code ) goto cleanup;
1181
1182     if ( lifetime == 0 )
1183         lifetime = pLeash_get_default_lifetime();
1184
1185     code = KFW_kinit(ctx, cc, HWND_DESKTOP,
1186                       pname,
1187                       password,
1188                       lifetime,
1189                       pLeash_get_default_forwardable(),
1190                       pLeash_get_default_proxiable(),
1191                       pLeash_get_default_renewable() ? pLeash_get_default_renew_till() : 0,
1192                       pLeash_get_default_noaddresses(),
1193                       pLeash_get_default_publicip());
1194     if ( IsDebuggerPresent() ) {
1195         char message[256];
1196         sprintf(message,"KFW_kinit() returns: %d\n",code);
1197         OutputDebugString(message);
1198     }
1199     if ( code ) goto cleanup;
1200
1201     KFW_AFS_update_princ_ccache_data(ctx, cc, FALSE);
1202
1203     code = KFW_AFS_klog(ctx, cc, "afs", cell, realm, lifetime,smbname);
1204     if ( IsDebuggerPresent() ) {
1205         char message[256];
1206         sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1207         OutputDebugString(message);
1208     }
1209     if ( code ) goto cleanup;
1210
1211     KFW_AFS_update_cell_princ_map(ctx, cell, pname, TRUE);
1212
1213     // Attempt to obtain new tokens for other cells supported by the same
1214     // principal
1215     cell_count = KFW_AFS_find_cells_for_princ(ctx, pname, &cells, TRUE);
1216     if ( cell_count > 1 ) {
1217         while ( cell_count-- ) {
1218             if ( strcmp(cells[cell_count],cell) ) {
1219                 if ( IsDebuggerPresent() ) {
1220                     char message[256];
1221                     sprintf(message,"found another cell for the same principal: %s\n",cell);
1222                     OutputDebugString(message);
1223                 }
1224                 code = KFW_AFS_get_cellconfig( cells[cell_count], (void*)&cellconfig, local_cell);
1225                 if ( code ) continue;
1226
1227                 realm = afs_realm_of_cell(ctx, &cellconfig);  // do not free
1228                 if ( IsDebuggerPresent() ) {
1229                     OutputDebugString("Realm: ");
1230                     OutputDebugString(realm);
1231                     OutputDebugString("\n");
1232                 }
1233
1234                 code = KFW_AFS_klog(ctx, cc, "afs", cells[cell_count], realm, lifetime,smbname);
1235                 if ( IsDebuggerPresent() ) {
1236                     char message[256];
1237                     sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1238                     OutputDebugString(message);
1239                 }
1240             }
1241             free(cells[cell_count]);
1242         }
1243         free(cells);
1244     } else if ( cell_count == 1 ) {
1245         free(cells[0]);
1246         free(cells);
1247     }
1248
1249   cleanup:
1250     if ( pname )
1251         pkrb5_free_unparsed_name(ctx,pname);
1252     if ( cc )
1253         pkrb5_cc_close(ctx, cc);
1254
1255     if ( code && reasonP ) {
1256         *reasonP = (char *)perror_message(code);
1257     }
1258     return(code);
1259 }
1260
1261 int
1262 KFW_AFS_destroy_tickets_for_cell(char * cell)
1263 {
1264     krb5_context                ctx = 0;
1265     krb5_error_code             code;
1266     int count;
1267     char ** principals = NULL;
1268
1269     if (!pkrb5_init_context)
1270         return 0;
1271
1272     if ( IsDebuggerPresent() ) {
1273         OutputDebugString("KFW_AFS_destroy_ticets_for_cell: ");
1274         OutputDebugString(cell);
1275         OutputDebugString("\n");
1276     }
1277
1278     code = pkrb5_init_context(&ctx);
1279     if (code) ctx = 0;
1280
1281     count = KFW_AFS_find_principals_for_cell(ctx, cell, &principals, FALSE);
1282     if ( count > 0 ) {
1283         krb5_principal      princ = 0;
1284         krb5_ccache                     cc  = 0;
1285
1286         while ( count-- ) {
1287             int cell_count = KFW_AFS_find_cells_for_princ(ctx, principals[count], NULL, TRUE);
1288             if ( cell_count > 1 ) {
1289                 // TODO - What we really should do here is verify whether or not any of the
1290                 // other cells which use this principal to obtain its credentials actually
1291                 // have valid tokens or not.  If they are currently using these credentials
1292                 // we will skip them.  For the time being we assume that if there is an active
1293                 // map in the table that they are actively being used.
1294                 goto loop_cleanup;
1295             }
1296
1297             code = pkrb5_parse_name(ctx, principals[count], &princ);
1298             if (code) goto loop_cleanup;
1299
1300             code = KFW_get_ccache(ctx, princ, &cc);
1301             if (code) goto loop_cleanup;
1302
1303             code = pkrb5_cc_destroy(ctx, cc);
1304             if (!code) cc = 0;
1305
1306           loop_cleanup:
1307             if ( cc ) {
1308                 pkrb5_cc_close(ctx, cc);
1309                 cc = 0;
1310             }
1311             if ( princ ) {
1312                 pkrb5_free_principal(ctx, princ);
1313                 princ = 0;
1314             }
1315
1316             KFW_AFS_update_cell_princ_map(ctx, cell, principals[count], FALSE);
1317             free(principals[count]);
1318         }
1319         free(principals);
1320     }
1321     pkrb5_free_context(ctx);
1322     return 0;
1323 }
1324
1325 int
1326 KFW_AFS_renew_expiring_tokens(void)
1327 {
1328     krb5_error_code                     code = 0;
1329     krb5_context                        ctx = 0;
1330     krb5_ccache                         cc = 0;
1331     krb5_timestamp now;
1332     struct principal_ccache_data * pcc_next = princ_cc_data;
1333     int cell_count;
1334     char ** cells=NULL;
1335     const char * realm = NULL;
1336     char local_cell[MAXCELLCHARS+1]="";
1337     struct afsconf_cell cellconfig;
1338
1339     if (!pkrb5_init_context)
1340         return 0;
1341
1342     if ( pcc_next == NULL ) // nothing to do
1343         return 0;
1344
1345     if ( IsDebuggerPresent() ) {
1346         OutputDebugString("KFW_AFS_renew_expiring_tokens\n");
1347     }
1348
1349     code = pkrb5_init_context(&ctx);
1350     if (code) goto cleanup;
1351
1352     code = pkrb5_timeofday(ctx, &now);
1353     if (code) goto cleanup;
1354
1355     for ( ; pcc_next ; pcc_next = pcc_next->next ) {
1356         if ( pcc_next->expired )
1357             continue;
1358
1359         if ( now >= (pcc_next->expiration_time) ) {
1360             if ( !pcc_next->from_lsa ) {
1361                 pcc_next->expired = 1;
1362                 continue;
1363             }
1364         }
1365
1366         if ( pcc_next->renew && now >= (pcc_next->expiration_time - cminRENEW * csec1MINUTE) ) {
1367             code = pkrb5_cc_resolve(ctx, pcc_next->ccache_name, &cc);
1368             if ( code )
1369                                 goto loop_cleanup;
1370             code = KFW_renew(ctx,cc);
1371 #ifdef USE_MS2MIT
1372             if ( code && pcc_next->from_lsa)
1373                 goto loop_cleanup;
1374 #endif /* USE_MS2MIT */
1375
1376
1377             KFW_AFS_update_princ_ccache_data(ctx, cc, pcc_next->from_lsa);
1378             if (code) goto loop_cleanup;
1379
1380             // Attempt to obtain new tokens for other cells supported by the same
1381             // principal
1382             cell_count = KFW_AFS_find_cells_for_princ(ctx, pcc_next->principal, &cells, TRUE);
1383             if ( cell_count > 0 ) {
1384                 while ( cell_count-- ) {
1385                     if ( IsDebuggerPresent() ) {
1386                         OutputDebugString("Cell: ");
1387                         OutputDebugString(cells[cell_count]);
1388                         OutputDebugString("\n");
1389                     }
1390                     code = KFW_AFS_get_cellconfig( cells[cell_count], (void*)&cellconfig, local_cell);
1391                     if ( code ) continue;
1392                     realm = afs_realm_of_cell(ctx, &cellconfig);  // do not free
1393                     if ( IsDebuggerPresent() ) {
1394                         OutputDebugString("Realm: ");
1395                         OutputDebugString(realm);
1396                         OutputDebugString("\n");
1397                     }
1398                     code = KFW_AFS_klog(ctx, cc, "afs", cells[cell_count], (char *)realm, pLeash_get_default_lifetime(),NULL);
1399                     if ( IsDebuggerPresent() ) {
1400                         char message[256];
1401                         sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1402                         OutputDebugString(message);
1403                     }
1404                     free(cells[cell_count]);
1405                 }
1406                 free(cells);
1407             }
1408         }
1409
1410       loop_cleanup:
1411         if ( cc ) {
1412             pkrb5_cc_close(ctx,cc);
1413             cc = 0;
1414         }
1415     }
1416
1417   cleanup:
1418     if ( cc )
1419         pkrb5_cc_close(ctx,cc);
1420     if ( ctx )
1421         pkrb5_free_context(ctx);
1422
1423     return 0;
1424 }
1425
1426
1427 BOOL
1428 KFW_AFS_renew_token_for_cell(char * cell)
1429 {
1430     krb5_error_code                     code = 0;
1431     krb5_context                        ctx = 0;
1432     int count;
1433     char ** principals = NULL;
1434
1435     if (!pkrb5_init_context)
1436         return 0;
1437
1438     if ( IsDebuggerPresent() ) {
1439         OutputDebugString("KFW_AFS_renew_token_for_cell:");
1440         OutputDebugString(cell);
1441         OutputDebugString("\n");
1442     }
1443
1444     code = pkrb5_init_context(&ctx);
1445     if (code) goto cleanup;
1446
1447     count = KFW_AFS_find_principals_for_cell(ctx, cell, &principals, TRUE);
1448     if ( count == 0 ) {
1449         // We know we must have a credential somewhere since we are
1450         // trying to renew a token
1451
1452         KFW_import_ccache_data();
1453         count = KFW_AFS_find_principals_for_cell(ctx, cell, &principals, TRUE);
1454     }
1455     if ( count > 0 ) {
1456         krb5_principal      princ = 0;
1457         krb5_principal      service = 0;
1458 #ifdef COMMENT
1459         krb5_creds          mcreds, creds;
1460 #endif /* COMMENT */
1461         krb5_ccache                     cc  = 0;
1462         const char * realm = NULL;
1463         struct afsconf_cell cellconfig;
1464         char local_cell[MAXCELLCHARS+1];
1465
1466         while ( count-- ) {
1467             code = pkrb5_parse_name(ctx, principals[count], &princ);
1468             if (code) goto loop_cleanup;
1469
1470             code = KFW_get_ccache(ctx, princ, &cc);
1471             if (code) goto loop_cleanup;
1472
1473             code = KFW_AFS_get_cellconfig( cell, (void*)&cellconfig, local_cell);
1474             if ( code ) goto loop_cleanup;
1475
1476             realm = afs_realm_of_cell(ctx, &cellconfig);  // do not free
1477             if ( IsDebuggerPresent() ) {
1478                 OutputDebugString("Realm: ");
1479                 OutputDebugString(realm);
1480                 OutputDebugString("\n");
1481             }
1482
1483 #ifdef COMMENT
1484             /* krb5_cc_remove_cred() is not implemented
1485              * for a single cred
1486              */
1487             code = pkrb5_build_principal(ctx, &service, strlen(realm),
1488                                           realm, "afs", cell, NULL);
1489             if (!code) {
1490                 memset(&mcreds, 0, sizeof(krb5_creds));
1491                 mcreds.client = princ;
1492                 mcreds.server = service;
1493
1494                 code = pkrb5_cc_retrieve_cred(ctx, cc, 0, &mcreds, &creds);
1495                 if (!code) {
1496                     if ( IsDebuggerPresent() ) {
1497                         char * cname, *sname;
1498                         pkrb5_unparse_name(ctx, creds.client, &cname);
1499                         pkrb5_unparse_name(ctx, creds.server, &sname);
1500                         OutputDebugString("Removing credential for client \"");
1501                         OutputDebugString(cname);
1502                         OutputDebugString("\" and service \"");
1503                         OutputDebugString(sname);
1504                         OutputDebugString("\"\n");
1505                         pkrb5_free_unparsed_name(ctx,cname);
1506                         pkrb5_free_unparsed_name(ctx,sname);
1507                     }
1508
1509                     code = pkrb5_cc_remove_cred(ctx, cc, 0, &creds);
1510                     pkrb5_free_principal(ctx, creds.client);
1511                     pkrb5_free_principal(ctx, creds.server);
1512                 }
1513             }
1514 #endif /* COMMENT */
1515
1516             code = KFW_AFS_klog(ctx, cc, "afs", cell, (char *)realm, pLeash_get_default_lifetime(),NULL);
1517             if ( IsDebuggerPresent() ) {
1518                 char message[256];
1519                 sprintf(message,"KFW_AFS_klog() returns: %d\n",code);
1520                 OutputDebugString(message);
1521             }
1522
1523           loop_cleanup:
1524             if (cc) {
1525                 pkrb5_cc_close(ctx, cc);
1526                 cc = 0;
1527             }
1528             if (princ) {
1529                 pkrb5_free_principal(ctx, princ);
1530                 princ = 0;
1531             }
1532             if (service) {
1533                 pkrb5_free_principal(ctx, service);
1534                 princ = 0;
1535             }
1536
1537             KFW_AFS_update_cell_princ_map(ctx, cell, principals[count], code ? FALSE : TRUE);
1538             free(principals[count]);
1539         }
1540         free(principals);
1541     } else
1542         code = -1;      // we did not renew the tokens
1543
1544   cleanup:
1545     pkrb5_free_context(ctx);
1546     return (code ? FALSE : TRUE);
1547
1548 }
1549
1550 int
1551 KFW_AFS_renew_tokens_for_all_cells(void)
1552 {
1553     struct cell_principal_map * next = cell_princ_map;
1554
1555     if ( IsDebuggerPresent() )
1556         OutputDebugString("KFW_AFS_renew_tokens_for_all()\n");
1557
1558     if ( !next )
1559         return 0;
1560
1561     for ( ; next ; next = next->next ) {
1562         if ( next->active )
1563             KFW_AFS_renew_token_for_cell(next->cell);
1564     }
1565     return 0;
1566 }
1567
1568 int
1569 KFW_renew(krb5_context alt_ctx, krb5_ccache alt_cc)
1570 {
1571     krb5_error_code                     code = 0;
1572     krb5_context                        ctx = 0;
1573     krb5_ccache                         cc = 0;
1574     krb5_principal                      me = 0;
1575     krb5_principal              server = 0;
1576     krb5_creds                          my_creds;
1577     krb5_data                   *realm = 0;
1578
1579     if (!pkrb5_init_context)
1580         return 0;
1581
1582         memset(&my_creds, 0, sizeof(krb5_creds));
1583
1584     if ( alt_ctx ) {
1585         ctx = alt_ctx;
1586     } else {
1587         code = pkrb5_init_context(&ctx);
1588         if (code) goto cleanup;
1589     }
1590
1591     if ( alt_cc ) {
1592         cc = alt_cc;
1593     } else {
1594         code = pkrb5_cc_default(ctx, &cc);
1595         if (code) goto cleanup;
1596     }
1597
1598     code = pkrb5_cc_get_principal(ctx, cc, &me);
1599     if (code) goto cleanup;
1600
1601     realm = krb5_princ_realm(ctx, me);
1602
1603     code = pkrb5_build_principal_ext(ctx, &server,
1604                                     realm->length,realm->data,
1605                                     KRB5_TGS_NAME_SIZE, KRB5_TGS_NAME,
1606                                     realm->length,realm->data,
1607                                     0);
1608     if ( code )
1609         goto cleanup;
1610
1611     if ( IsDebuggerPresent() ) {
1612         char * cname, *sname;
1613         pkrb5_unparse_name(ctx, me, &cname);
1614         pkrb5_unparse_name(ctx, server, &sname);
1615         OutputDebugString("Renewing credential for client \"");
1616         OutputDebugString(cname);
1617         OutputDebugString("\" and service \"");
1618         OutputDebugString(sname);
1619         OutputDebugString("\"\n");
1620         pkrb5_free_unparsed_name(ctx,cname);
1621         pkrb5_free_unparsed_name(ctx,sname);
1622     }
1623
1624     my_creds.client = me;
1625     my_creds.server = server;
1626
1627     code = pkrb5_get_renewed_creds(ctx, &my_creds, me, cc, NULL);
1628     if (code) {
1629         if ( IsDebuggerPresent() ) {
1630             char message[256];
1631             sprintf(message,"krb5_get_renewed_creds() failed: %d\n",code);
1632             OutputDebugString(message);
1633         }
1634         goto cleanup;
1635     }
1636
1637     code = pkrb5_cc_initialize(ctx, cc, me);
1638     if (code) {
1639         if ( IsDebuggerPresent() ) {
1640             char message[256];
1641             sprintf(message,"krb5_cc_initialize() failed: %d\n",code);
1642             OutputDebugString(message);
1643         }
1644         goto cleanup;
1645     }
1646
1647     code = pkrb5_cc_store_cred(ctx, cc, &my_creds);
1648     if (code) {
1649         if ( IsDebuggerPresent() ) {
1650             char message[256];
1651             sprintf(message,"krb5_cc_store_cred() failed: %d\n",code);
1652             OutputDebugString(message);
1653         }
1654         goto cleanup;
1655     }
1656
1657   cleanup:
1658     if (my_creds.client == me)
1659         my_creds.client = 0;
1660     if (my_creds.server == server)
1661         my_creds.server = 0;
1662     pkrb5_free_cred_contents(ctx, &my_creds);
1663     if (me)
1664         pkrb5_free_principal(ctx, me);
1665     if (server)
1666         pkrb5_free_principal(ctx, server);
1667     if (cc && (cc != alt_cc))
1668         pkrb5_cc_close(ctx, cc);
1669     if (ctx && (ctx != alt_ctx))
1670         pkrb5_free_context(ctx);
1671     return(code);
1672 }
1673
1674 int
1675 KFW_kinit( krb5_context alt_ctx,
1676             krb5_ccache  alt_cc,
1677             HWND hParent,
1678             char *principal_name,
1679             char *password,
1680             krb5_deltat lifetime,
1681             DWORD                       forwardable,
1682             DWORD                       proxiable,
1683             krb5_deltat                 renew_life,
1684             DWORD                       addressless,
1685             DWORD                       publicIP
1686             )
1687 {
1688     krb5_error_code                     code = 0;
1689     krb5_context                        ctx = 0;
1690     krb5_ccache                         cc = 0;
1691     krb5_principal                      me = 0;
1692     char*                       name = 0;
1693     krb5_creds                          my_creds;
1694     krb5_get_init_creds_opt     options;
1695     krb5_address **             addrs = NULL;
1696     int                         i = 0, addr_count = 0;
1697
1698     if (!pkrb5_init_context)
1699         return 0;
1700
1701     pkrb5_get_init_creds_opt_init(&options);
1702     memset(&my_creds, 0, sizeof(my_creds));
1703
1704     if (alt_ctx)
1705     {
1706         ctx = alt_ctx;
1707     }
1708     else
1709     {
1710         code = pkrb5_init_context(&ctx);
1711         if (code) goto cleanup;
1712     }
1713
1714     if ( alt_cc ) {
1715         cc = alt_cc;
1716     } else {
1717         code = pkrb5_cc_default(ctx, &cc);
1718         if (code) goto cleanup;
1719     }
1720
1721     code = pkrb5_parse_name(ctx, principal_name, &me);
1722     if (code)
1723                 goto cleanup;
1724
1725     code = pkrb5_unparse_name(ctx, me, &name);
1726     if (code)
1727                 goto cleanup;
1728
1729     if (lifetime == 0)
1730         lifetime = pLeash_get_default_lifetime();
1731     else
1732         lifetime *= 5*60;
1733
1734         if (renew_life > 0)
1735                 renew_life *= 5*60;
1736
1737     if (lifetime)
1738         pkrb5_get_init_creds_opt_set_tkt_life(&options, lifetime);
1739         pkrb5_get_init_creds_opt_set_forwardable(&options,
1740                                                  forwardable ? 1 : 0);
1741         pkrb5_get_init_creds_opt_set_proxiable(&options,
1742                                                proxiable ? 1 : 0);
1743         pkrb5_get_init_creds_opt_set_renew_life(&options,
1744                                                renew_life);
1745     if (addressless)
1746         pkrb5_get_init_creds_opt_set_address_list(&options,NULL);
1747     else {
1748                 if (publicIP)
1749         {
1750             // we are going to add the public IP address specified by the user
1751             // to the list provided by the operating system
1752             krb5_address ** local_addrs=NULL;
1753             DWORD           netIPAddr;
1754
1755             pkrb5_os_localaddr(ctx, &local_addrs);
1756             while ( local_addrs[i++] );
1757             addr_count = i + 1;
1758
1759             addrs = (krb5_address **) malloc((addr_count+1) * sizeof(krb5_address *));
1760             if ( !addrs ) {
1761                 pkrb5_free_addresses(ctx, local_addrs);
1762                 goto cleanup;
1763             }
1764             memset(addrs, 0, sizeof(krb5_address *) * (addr_count+1));
1765             i = 0;
1766             while ( local_addrs[i] ) {
1767                 addrs[i] = (krb5_address *)malloc(sizeof(krb5_address));
1768                 if (addrs[i] == NULL) {
1769                     pkrb5_free_addresses(ctx, local_addrs);
1770                     goto cleanup;
1771                 }
1772
1773                 addrs[i]->magic = local_addrs[i]->magic;
1774                 addrs[i]->addrtype = local_addrs[i]->addrtype;
1775                 addrs[i]->length = local_addrs[i]->length;
1776                 addrs[i]->contents = (unsigned char *)malloc(addrs[i]->length);
1777                 if (!addrs[i]->contents) {
1778                     pkrb5_free_addresses(ctx, local_addrs);
1779                     goto cleanup;
1780                 }
1781
1782                 memcpy(addrs[i]->contents,local_addrs[i]->contents,
1783                         local_addrs[i]->length);        /* safe */
1784                 i++;
1785             }
1786             pkrb5_free_addresses(ctx, local_addrs);
1787
1788             addrs[i] = (krb5_address *)malloc(sizeof(krb5_address));
1789             if (addrs[i] == NULL)
1790                 goto cleanup;
1791
1792             addrs[i]->magic = KV5M_ADDRESS;
1793             addrs[i]->addrtype = AF_INET;
1794             addrs[i]->length = 4;
1795             addrs[i]->contents = (unsigned char *)malloc(addrs[i]->length);
1796             if (!addrs[i]->contents)
1797                 goto cleanup;
1798
1799             netIPAddr = htonl(publicIP);
1800             memcpy(addrs[i]->contents,&netIPAddr,4);
1801
1802             pkrb5_get_init_creds_opt_set_address_list(&options,addrs);
1803
1804         }
1805     }
1806
1807     code = pkrb5_get_init_creds_password(ctx,
1808                                        &my_creds,
1809                                        me,
1810                                        password, // password
1811                                        KRB5_prompter, // prompter
1812                                        hParent, // prompter data
1813                                        0, // start time
1814                                        0, // service name
1815                                        &options);
1816     if (code)
1817                 goto cleanup;
1818
1819     code = pkrb5_cc_initialize(ctx, cc, me);
1820     if (code)
1821                 goto cleanup;
1822
1823     code = pkrb5_cc_store_cred(ctx, cc, &my_creds);
1824     if (code)
1825                 goto cleanup;
1826
1827  cleanup:
1828     if ( addrs ) {
1829         for ( i=0;i<addr_count;i++ ) {
1830             if ( addrs[i] ) {
1831                 if ( addrs[i]->contents )
1832                     free(addrs[i]->contents);
1833                 free(addrs[i]);
1834             }
1835         }
1836     }
1837     if (my_creds.client == me)
1838         my_creds.client = 0;
1839     pkrb5_free_cred_contents(ctx, &my_creds);
1840     if (name)
1841         pkrb5_free_unparsed_name(ctx, name);
1842     if (me)
1843         pkrb5_free_principal(ctx, me);
1844     if (cc && (cc != alt_cc))
1845         pkrb5_cc_close(ctx, cc);
1846     if (ctx && (ctx != alt_ctx))
1847         pkrb5_free_context(ctx);
1848     return(code);
1849 }
1850
1851
1852 int
1853 KFW_kdestroy(krb5_context alt_ctx, krb5_ccache alt_cc)
1854 {
1855     krb5_context                ctx;
1856     krb5_ccache                 cc;
1857     krb5_error_code             code;
1858
1859     if (!pkrb5_init_context)
1860         return 0;
1861
1862     if (alt_ctx)
1863     {
1864         ctx = alt_ctx;
1865     }
1866     else
1867     {
1868         code = pkrb5_init_context(&ctx);
1869         if (code) goto cleanup;
1870     }
1871
1872     if ( alt_cc ) {
1873         cc = alt_cc;
1874     } else {
1875         code = pkrb5_cc_default(ctx, &cc);
1876         if (code) goto cleanup;
1877     }
1878
1879     code = pkrb5_cc_destroy(ctx, cc);
1880     if ( !code ) cc = 0;
1881
1882   cleanup:
1883     if (cc && (cc != alt_cc))
1884         pkrb5_cc_close(ctx, cc);
1885     if (ctx && (ctx != alt_ctx))
1886         pkrb5_free_context(ctx);
1887
1888     return(code);
1889 }
1890
1891
1892 #ifdef USE_MS2MIT
1893 static BOOL
1894 GetSecurityLogonSessionData(PSECURITY_LOGON_SESSION_DATA * ppSessionData)
1895 {
1896     NTSTATUS Status = 0;
1897     HANDLE  TokenHandle;
1898     TOKEN_STATISTICS Stats;
1899     DWORD   ReqLen;
1900     BOOL    Success;
1901
1902     if (!ppSessionData)
1903         return FALSE;
1904     *ppSessionData = NULL;
1905
1906     Success = OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &TokenHandle );
1907     if ( !Success )
1908         return FALSE;
1909
1910     Success = GetTokenInformation( TokenHandle, TokenStatistics, &Stats, sizeof(TOKEN_STATISTICS), &ReqLen );
1911     CloseHandle( TokenHandle );
1912     if ( !Success )
1913         return FALSE;
1914
1915     Status = pLsaGetLogonSessionData( &Stats.AuthenticationId, ppSessionData );
1916     if ( FAILED(Status) || !ppSessionData )
1917         return FALSE;
1918
1919     return TRUE;
1920 }
1921
1922 //
1923 // MSLSA_IsKerberosLogon() does not validate whether or not there are valid tickets in the
1924 // cache.  It validates whether or not it is reasonable to assume that if we
1925 // attempted to retrieve valid tickets we could do so.  Microsoft does not
1926 // automatically renew expired tickets.  Therefore, the cache could contain
1927 // expired or invalid tickets.  Microsoft also caches the user's password
1928 // and will use it to retrieve new TGTs if the cache is empty and tickets
1929 // are requested.
1930
1931 static BOOL
1932 MSLSA_IsKerberosLogon(VOID)
1933 {
1934     PSECURITY_LOGON_SESSION_DATA pSessionData = NULL;
1935     BOOL    Success = FALSE;
1936
1937     if ( GetSecurityLogonSessionData(&pSessionData) ) {
1938         if ( pSessionData->AuthenticationPackage.Buffer ) {
1939             WCHAR buffer[256];
1940             WCHAR *usBuffer;
1941             int usLength;
1942
1943             Success = FALSE;
1944             usBuffer = (pSessionData->AuthenticationPackage).Buffer;
1945             usLength = (pSessionData->AuthenticationPackage).Length;
1946             if (usLength < 256)
1947             {
1948                 lstrcpynW (buffer, usBuffer, usLength);
1949                 lstrcatW (buffer,L"");
1950                 if ( !lstrcmpW(L"Kerberos",buffer) )
1951                     Success = TRUE;
1952             }
1953         }
1954         pLsaFreeReturnBuffer(pSessionData);
1955     }
1956     return Success;
1957 }
1958 #endif /* USE_MS2MIT */
1959
1960 static BOOL CALLBACK
1961 MultiInputDialogProc( HWND hDialog, UINT message, WPARAM wParam, LPARAM lParam)
1962 {
1963     int i;
1964
1965     switch ( message ) {
1966     case WM_INITDIALOG:
1967         if ( GetDlgCtrlID((HWND) wParam) != ID_MID_TEXT )
1968         {
1969             SetFocus(GetDlgItem( hDialog, ID_MID_TEXT));
1970             return FALSE;
1971         }
1972                 for ( i=0; i < mid_cnt ; i++ ) {
1973                         if (mid_tb[i].echo == 0)
1974                                 SendDlgItemMessage(hDialog, ID_MID_TEXT+i, EM_SETPASSWORDCHAR, 32, 0);
1975                     else if (mid_tb[i].echo == 2)
1976                                 SendDlgItemMessage(hDialog, ID_MID_TEXT+i, EM_SETPASSWORDCHAR, '*', 0);
1977                 }
1978         return TRUE;
1979
1980     case WM_COMMAND:
1981         switch ( LOWORD(wParam) ) {
1982         case IDOK:
1983             for ( i=0; i < mid_cnt ; i++ ) {
1984                 if ( !GetDlgItemText(hDialog, ID_MID_TEXT+i, mid_tb[i].buf, mid_tb[i].len) )
1985                     *mid_tb[i].buf = '\0';
1986             }
1987             /* fallthrough */
1988         case IDCANCEL:
1989             EndDialog(hDialog, LOWORD(wParam));
1990             return TRUE;
1991         }
1992     }
1993     return FALSE;
1994 }
1995
1996 static LPWORD
1997 lpwAlign( LPWORD lpIn )
1998 {
1999     ULONG ul;
2000
2001     ul = (ULONG) lpIn;
2002     ul += 3;
2003     ul >>=2;
2004     ul <<=2;
2005     return (LPWORD) ul;;
2006 }
2007
2008 /*
2009  * dialog widths are measured in 1/4 character widths
2010  * dialog height are measured in 1/8 character heights
2011  */
2012
2013 static LRESULT
2014 MultiInputDialog( HINSTANCE hinst, HWND hwndOwner,
2015                   char * ptext[], int numlines, int width,
2016                   int tb_cnt, struct textField * tb)
2017 {
2018     HGLOBAL hgbl;
2019     LPDLGTEMPLATE lpdt;
2020     LPDLGITEMTEMPLATE lpdit;
2021     LPWORD lpw;
2022     LPWSTR lpwsz;
2023     LRESULT ret;
2024     int nchar, i, pwid;
2025
2026     hgbl = GlobalAlloc(GMEM_ZEROINIT, 4096);
2027     if (!hgbl)
2028         return -1;
2029
2030     mid_cnt = tb_cnt;
2031     mid_tb = tb;
2032
2033     lpdt = (LPDLGTEMPLATE)GlobalLock(hgbl);
2034
2035     // Define a dialog box.
2036
2037     lpdt->style = WS_POPUP | WS_BORDER | WS_SYSMENU
2038                    | DS_MODALFRAME | WS_CAPTION | DS_CENTER
2039                    | DS_SETFOREGROUND | DS_3DLOOK
2040                    | DS_SETFONT | DS_FIXEDSYS | DS_NOFAILCREATE;
2041     lpdt->cdit = numlines + (2 * tb_cnt) + 2;  // number of controls
2042     lpdt->x  = 10;
2043     lpdt->y  = 10;
2044     lpdt->cx = 20 + width * 4;
2045     lpdt->cy = 20 + (numlines + tb_cnt + 4) * 14;
2046
2047     lpw = (LPWORD) (lpdt + 1);
2048     *lpw++ = 0;   // no menu
2049     *lpw++ = 0;   // predefined dialog box class (by default)
2050
2051     lpwsz = (LPWSTR) lpw;
2052     nchar = MultiByteToWideChar (CP_ACP, 0, "", -1, lpwsz, 128);
2053     lpw   += nchar;
2054     *lpw++ = 8;                        // font size (points)
2055     lpwsz = (LPWSTR) lpw;
2056     nchar = MultiByteToWideChar (CP_ACP, 0, "MS Shell Dlg",
2057                                     -1, lpwsz, 128);
2058     lpw   += nchar;
2059
2060     //-----------------------
2061     // Define an OK button.
2062     //-----------------------
2063     lpw = lpwAlign (lpw); // align DLGITEMTEMPLATE on DWORD boundary
2064     lpdit = (LPDLGITEMTEMPLATE) lpw;
2065     lpdit->style = WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON | WS_TABSTOP | WS_BORDER;
2066     lpdit->dwExtendedStyle = 0;
2067     lpdit->x  = (lpdt->cx - 14)/4 - 20;
2068     lpdit->y  = 10 + (numlines + tb_cnt + 2) * 14;
2069     lpdit->cx = 40;
2070     lpdit->cy = 14;
2071     lpdit->id = IDOK;  // OK button identifier
2072
2073     lpw = (LPWORD) (lpdit + 1);
2074     *lpw++ = 0xFFFF;
2075     *lpw++ = 0x0080;    // button class
2076
2077     lpwsz = (LPWSTR) lpw;
2078     nchar = MultiByteToWideChar (CP_ACP, 0, "OK", -1, lpwsz, 50);
2079     lpw   += nchar;
2080     *lpw++ = 0;           // no creation data
2081
2082     //-----------------------
2083     // Define an Cancel button.
2084     //-----------------------
2085     lpw = lpwAlign (lpw); // align DLGITEMTEMPLATE on DWORD boundary
2086     lpdit = (LPDLGITEMTEMPLATE) lpw;
2087     lpdit->style = WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP | WS_BORDER;
2088     lpdit->dwExtendedStyle = 0;
2089     lpdit->x  = (lpdt->cx - 14)*3/4 - 20;
2090     lpdit->y  = 10 + (numlines + tb_cnt + 2) * 14;
2091     lpdit->cx = 40;
2092     lpdit->cy = 14;
2093     lpdit->id = IDCANCEL;  // CANCEL button identifier
2094
2095     lpw = (LPWORD) (lpdit + 1);
2096     *lpw++ = 0xFFFF;
2097     *lpw++ = 0x0080;    // button class
2098
2099     lpwsz = (LPWSTR) lpw;
2100     nchar = MultiByteToWideChar (CP_ACP, 0, "Cancel", -1, lpwsz, 50);
2101     lpw   += nchar;
2102     *lpw++ = 0;           // no creation data
2103
2104     /* Add controls for preface data */
2105     for ( i=0; i<numlines; i++) {
2106         /*-----------------------
2107          * Define a static text control.
2108          *-----------------------*/
2109         lpw = lpwAlign (lpw); /* align DLGITEMTEMPLATE on DWORD boundary */
2110         lpdit = (LPDLGITEMTEMPLATE) lpw;
2111         lpdit->style = WS_CHILD | WS_VISIBLE | SS_LEFT;
2112         lpdit->dwExtendedStyle = 0;
2113         lpdit->x  = 10;
2114         lpdit->y  = 10 + i * 14;
2115         lpdit->cx = strlen(ptext[i]) * 4 + 10;
2116         lpdit->cy = 14;
2117         lpdit->id = ID_TEXT + i;  // text identifier
2118
2119         lpw = (LPWORD) (lpdit + 1);
2120         *lpw++ = 0xFFFF;
2121         *lpw++ = 0x0082;                         // static class
2122
2123         lpwsz = (LPWSTR) lpw;
2124         nchar = MultiByteToWideChar (CP_ACP, 0, ptext[i],
2125                                          -1, lpwsz, 2*width);
2126         lpw   += nchar;
2127         *lpw++ = 0;           // no creation data
2128     }
2129
2130     for ( i=0, pwid = 0; i<tb_cnt; i++) {
2131         if ( pwid < strlen(tb[i].label) )
2132             pwid = strlen(tb[i].label);
2133     }
2134
2135     for ( i=0; i<tb_cnt; i++) {
2136         /* Prompt */
2137         /*-----------------------
2138          * Define a static text control.
2139          *-----------------------*/
2140         lpw = lpwAlign (lpw); /* align DLGITEMTEMPLATE on DWORD boundary */
2141         lpdit = (LPDLGITEMTEMPLATE) lpw;
2142         lpdit->style = WS_CHILD | WS_VISIBLE | SS_LEFT;
2143         lpdit->dwExtendedStyle = 0;
2144         lpdit->x  = 10;
2145         lpdit->y  = 10 + (numlines + i + 1) * 14;
2146         lpdit->cx = pwid * 4;
2147         lpdit->cy = 14;
2148         lpdit->id = ID_TEXT + numlines + i;  // text identifier
2149
2150         lpw = (LPWORD) (lpdit + 1);
2151         *lpw++ = 0xFFFF;
2152         *lpw++ = 0x0082;                         // static class
2153
2154         lpwsz = (LPWSTR) lpw;
2155         nchar = MultiByteToWideChar (CP_ACP, 0, tb[i].label ? tb[i].label : "",
2156                                      -1, lpwsz, 128);
2157         lpw   += nchar;
2158         *lpw++ = 0;           // no creation data
2159
2160         /*-----------------------
2161          * Define an edit control.
2162          *-----------------------*/
2163         lpw = lpwAlign (lpw); /* align DLGITEMTEMPLATE on DWORD boundary */
2164         lpdit = (LPDLGITEMTEMPLATE) lpw;
2165         lpdit->style = WS_CHILD | WS_VISIBLE | ES_LEFT | WS_TABSTOP | WS_BORDER | (tb[i].echo == 1 ? 0L : ES_PASSWORD);
2166         lpdit->dwExtendedStyle = 0;
2167         lpdit->x  = 10 + (pwid + 1) * 4;
2168         lpdit->y  = 10 + (numlines + i + 1) * 14;
2169         lpdit->cx = (width - (pwid + 1)) * 4;
2170         lpdit->cy = 14;
2171         lpdit->id = ID_MID_TEXT + i;             // identifier
2172
2173         lpw = (LPWORD) (lpdit + 1);
2174         *lpw++ = 0xFFFF;
2175         *lpw++ = 0x0081;                         // edit class
2176
2177         lpwsz = (LPWSTR) lpw;
2178         nchar = MultiByteToWideChar (CP_ACP, 0, tb[i].def ? tb[i].def : "",
2179                                      -1, lpwsz, 128);
2180         lpw   += nchar;
2181         *lpw++ = 0;           // no creation data
2182     }
2183
2184     GlobalUnlock(hgbl);
2185     ret = DialogBoxIndirect(hinst, (LPDLGTEMPLATE) hgbl,
2186                                                         hwndOwner, (DLGPROC) MultiInputDialogProc);
2187     GlobalFree(hgbl);
2188
2189     switch ( ret ) {
2190     case 0:     /* Timeout */
2191         return -1;
2192     case IDOK:
2193         return 1;
2194     case IDCANCEL:
2195         return 0;
2196     default: {
2197         char buf[256];
2198         sprintf(buf,"DialogBoxIndirect() failed: %d",GetLastError());
2199         MessageBox(hwndOwner,
2200                     buf,
2201                     "GetLastError()",
2202                     MB_OK | MB_ICONINFORMATION | MB_TASKMODAL);
2203         return -1;
2204     }
2205     }
2206 }
2207
2208 static int
2209 multi_field_dialog(HWND hParent, char * preface, int n, struct textField tb[])
2210 {
2211         HINSTANCE hInst = 0;
2212     int maxwidth = 0;
2213     int numlines = 0;
2214     int len;
2215     char * plines[16], *p = preface ? preface : "";
2216     int i;
2217
2218     for ( i=0; i<16; i++ )
2219         plines[i] = NULL;
2220
2221     while (*p && numlines < 16) {
2222         plines[numlines++] = p;
2223         for ( ;*p && *p != '\r' && *p != '\n'; p++ );
2224         if ( *p == '\r' && *(p+1) == '\n' ) {
2225             *p++ = '\0';
2226             p++;
2227         } else if ( *p == '\n' ) {
2228             *p++ = '\0';
2229         }
2230         if ( strlen(plines[numlines-1]) > maxwidth )
2231             maxwidth = strlen(plines[numlines-1]);
2232     }
2233
2234     for ( i=0;i<n;i++ ) {
2235         len = strlen(tb[i].label) + 1 + (tb[i].len > 40 ? 40 : tb[i].len);
2236         if ( maxwidth < len )
2237             maxwidth = len;
2238     }
2239
2240     return(MultiInputDialog(hInst, hParent, plines, numlines, maxwidth, n, tb));
2241 }
2242
2243 static krb5_error_code KRB5_CALLCONV
2244 KRB5_prompter( krb5_context context,
2245                void *data,
2246                const char *name,
2247                const char *banner,
2248                int num_prompts,
2249                krb5_prompt prompts[])
2250 {
2251     krb5_error_code     errcode = 0;
2252     int                 i;
2253     struct textField * tb = NULL;
2254     int    len = 0, blen=0, nlen=0;
2255         HWND hParent = (HWND)data;
2256
2257     if (name)
2258         nlen = strlen(name)+2;
2259
2260     if (banner)
2261         blen = strlen(banner)+2;
2262
2263     tb = (struct textField *) malloc(sizeof(struct textField) * num_prompts);
2264     if ( tb != NULL ) {
2265         int ok;
2266         memset(tb,0,sizeof(struct textField) * num_prompts);
2267         for ( i=0; i < num_prompts; i++ ) {
2268             tb[i].buf = prompts[i].reply->data;
2269             tb[i].len = prompts[i].reply->length;
2270             tb[i].label = prompts[i].prompt;
2271             tb[i].def = NULL;
2272             tb[i].echo = (prompts[i].hidden ? 2 : 1);
2273         }
2274
2275         ok = multi_field_dialog(hParent,(char *)banner,num_prompts,tb);
2276         if ( ok ) {
2277             for ( i=0; i < num_prompts; i++ )
2278                 prompts[i].reply->length = strlen(prompts[i].reply->data);
2279         } else
2280             errcode = -2;
2281     }
2282
2283     if ( tb )
2284         free(tb);
2285     if (errcode) {
2286         for (i = 0; i < num_prompts; i++) {
2287             memset(prompts[i].reply->data, 0, prompts[i].reply->length);
2288         }
2289     }
2290     return errcode;
2291 }
2292
2293 BOOL
2294 KFW_AFS_wait_for_service_start(void)
2295 {
2296     char    HostName[64];
2297     DWORD   CurrentState;
2298
2299     CurrentState = SERVICE_START_PENDING;
2300     memset(HostName, '\0', sizeof(HostName));
2301     gethostname(HostName, sizeof(HostName));
2302
2303     while (CurrentState != SERVICE_RUNNING || CurrentState != SERVICE_STOPPED)
2304     {
2305         if (GetServiceStatus(HostName, TRANSARCAFSDAEMON, &CurrentState) != NOERROR)
2306             return(0);
2307         if ( IsDebuggerPresent() ) {
2308             switch ( CurrentState ) {
2309             case SERVICE_STOPPED:
2310                 OutputDebugString("SERVICE_STOPPED\n");
2311                 break;
2312             case SERVICE_START_PENDING:
2313                 OutputDebugString("SERVICE_START_PENDING\n");
2314                 break;
2315             case SERVICE_STOP_PENDING:
2316                 OutputDebugString("SERVICE_STOP_PENDING\n");
2317                 break;
2318             case SERVICE_RUNNING:
2319                 OutputDebugString("SERVICE_RUNNING\n");
2320                 break;
2321             case SERVICE_CONTINUE_PENDING:
2322                 OutputDebugString("SERVICE_CONTINUE_PENDING\n");
2323                 break;
2324             case SERVICE_PAUSE_PENDING:
2325                 OutputDebugString("SERVICE_PAUSE_PENDING\n");
2326                 break;
2327             case SERVICE_PAUSED:
2328                 OutputDebugString("SERVICE_PAUSED\n");
2329                 break;
2330             default:
2331                 OutputDebugString("UNKNOWN Service State\n");
2332             }
2333         }
2334         if (CurrentState == SERVICE_STOPPED)
2335             return(0);
2336         if (CurrentState == SERVICE_RUNNING)
2337             return(1);
2338         Sleep(500);
2339     }
2340     return(0);
2341 }
2342
2343
2344 int
2345 KFW_AFS_unlog(void)
2346 {
2347     long        rc;
2348     char    HostName[64];
2349     DWORD   CurrentState;
2350
2351     CurrentState = 0;
2352     memset(HostName, '\0', sizeof(HostName));
2353     gethostname(HostName, sizeof(HostName));
2354     if (GetServiceStatus(HostName, TRANSARCAFSDAEMON, &CurrentState) != NOERROR)
2355         return(0);
2356     if (CurrentState != SERVICE_RUNNING)
2357         return(0);
2358
2359     rc = ktc_ForgetAllTokens();
2360
2361     return(0);
2362 }
2363
2364 int
2365 KFW_AFS_klog(
2366     krb5_context alt_ctx,
2367     krb5_ccache  alt_cc,
2368     char *service,
2369     char *cell,
2370     char *realm,
2371     int LifeTime,
2372     char *smbname
2373     )
2374 {
2375     long        rc = 0;
2376     CREDENTIALS creds;
2377     KTEXT_ST    ticket;
2378     struct ktc_principal        aserver;
2379     struct ktc_principal        aclient;
2380     char        realm_of_user[REALM_SZ]; /* Kerberos realm of user */
2381     char        realm_of_cell[REALM_SZ]; /* Kerberos realm of cell */
2382     char        local_cell[MAXCELLCHARS+1];
2383     char        Dmycell[MAXCELLCHARS+1];
2384     struct ktc_token    atoken;
2385     struct ktc_token    btoken;
2386     struct afsconf_cell ak_cellconfig; /* General information about the cell */
2387     char        RealmName[128];
2388     char        CellName[128];
2389     char        ServiceName[128];
2390     DWORD       CurrentState;
2391     char        HostName[64];
2392     BOOL        try_krb5 = 0;
2393     krb5_context  ctx = 0;
2394     krb5_ccache   cc = 0;
2395     krb5_creds increds;
2396     krb5_creds * k5creds = 0;
2397     krb5_error_code code;
2398     krb5_principal client_principal = 0;
2399     int i, retry = 0;
2400
2401     CurrentState = 0;
2402     memset(HostName, '\0', sizeof(HostName));
2403     gethostname(HostName, sizeof(HostName));
2404     if (GetServiceStatus(HostName, TRANSARCAFSDAEMON, &CurrentState) != NOERROR) {
2405         if ( IsDebuggerPresent() )
2406             OutputDebugString("Unable to retrieve AFSD Service Status\n");
2407         return(-1);
2408     }
2409     if (CurrentState != SERVICE_RUNNING) {
2410         if ( IsDebuggerPresent() )
2411             OutputDebugString("AFSD Service NOT RUNNING\n");
2412         return(-2);
2413     }
2414
2415     if (!pkrb5_init_context)
2416         return 0;
2417
2418     memset(RealmName, '\0', sizeof(RealmName));
2419     memset(CellName, '\0', sizeof(CellName));
2420     memset(ServiceName, '\0', sizeof(ServiceName));
2421     memset(realm_of_user, '\0', sizeof(realm_of_user));
2422     memset(realm_of_cell, '\0', sizeof(realm_of_cell));
2423         if (cell && cell[0])
2424                 strcpy(Dmycell, cell);
2425         else
2426                 memset(Dmycell, '\0', sizeof(Dmycell));
2427
2428     // NULL or empty cell returns information on local cell
2429     if (rc = KFW_AFS_get_cellconfig(Dmycell, &ak_cellconfig, local_cell))
2430     {
2431         // KFW_AFS_error(rc, "get_cellconfig()");
2432         return(rc);
2433     }
2434
2435     if ( alt_ctx ) {
2436         ctx = alt_ctx;
2437     } else {
2438         code = pkrb5_init_context(&ctx);
2439         if (code) goto cleanup;
2440     }
2441
2442     if ( alt_cc ) {
2443         cc = alt_cc;
2444     } else {
2445         code = pkrb5_cc_default(ctx, &cc);
2446         if (code) goto skip_krb5_init;
2447     }
2448
2449     memset((char *)&increds, 0, sizeof(increds));
2450
2451     code = pkrb5_cc_get_principal(ctx, cc, &client_principal);
2452         if (code) {
2453         if ( code == KRB5_CC_NOTFOUND && IsDebuggerPresent() )
2454         {
2455             OutputDebugString("Principal Not Found for ccache\n");
2456         }
2457         goto skip_krb5_init;
2458     }
2459     i = krb5_princ_realm(ctx, client_principal)->length;
2460     if (i > REALM_SZ-1)
2461         i = REALM_SZ-1;
2462     strncpy(realm_of_user,krb5_princ_realm(ctx, client_principal)->data,i);
2463     realm_of_user[i] = 0;
2464     try_krb5 = 1;
2465
2466   skip_krb5_init:
2467 #ifdef USE_KRB4
2468     if ( !try_krb5 || !realm_of_user[0] ) {
2469         if ((rc = (*pkrb_get_tf_realm)((*ptkt_string)(), realm_of_user)) != KSUCCESS)
2470         {
2471             goto cleanup;
2472         }
2473     }
2474 #else
2475     goto cleanup;
2476 #endif
2477     strcpy(realm_of_cell, afs_realm_of_cell(ctx, &ak_cellconfig));
2478
2479     if (strlen(service) == 0)
2480         strcpy(ServiceName, "afs");
2481     else
2482         strcpy(ServiceName, service);
2483
2484     if (strlen(cell) == 0)
2485         strcpy(CellName, local_cell);
2486     else
2487         strcpy(CellName, cell);
2488
2489     if (strlen(realm) == 0)
2490         strcpy(RealmName, realm_of_cell);
2491     else
2492         strcpy(RealmName, realm);
2493
2494     memset(&creds, '\0', sizeof(creds));
2495
2496     if ( try_krb5 ) {
2497         int len;
2498
2499         /* First try service/cell@REALM */
2500         if (code = pkrb5_build_principal(ctx, &increds.server,
2501                                           strlen(RealmName),
2502                                           RealmName,
2503                                           ServiceName,
2504                                           CellName,
2505                                           0))
2506         {
2507             goto cleanup;
2508         }
2509
2510         increds.client = client_principal;
2511         increds.times.endtime = 0;
2512         /* Ask for DES since that is what V4 understands */
2513         increds.keyblock.enctype = ENCTYPE_DES_CBC_CRC;
2514
2515
2516         if ( IsDebuggerPresent() ) {
2517             char * cname, *sname;
2518             pkrb5_unparse_name(ctx, increds.client, &cname);
2519             pkrb5_unparse_name(ctx, increds.server, &sname);
2520             OutputDebugString("Getting tickets for \"");
2521             OutputDebugString(cname);
2522             OutputDebugString("\" and service \"");
2523             OutputDebugString(sname);
2524             OutputDebugString("\"\n");
2525             pkrb5_free_unparsed_name(ctx,cname);
2526             pkrb5_free_unparsed_name(ctx,sname);
2527         }
2528
2529         code = pkrb5_get_credentials(ctx, 0, cc, &increds, &k5creds);
2530         if (code == KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN ||
2531              code == KRB5KRB_ERR_GENERIC /* heimdal */ ||
2532                          code == KRB5KRB_AP_ERR_MSG_TYPE) {
2533             /* Or service@REALM */
2534             pkrb5_free_principal(ctx,increds.server);
2535             increds.server = 0;
2536             code = pkrb5_build_principal(ctx, &increds.server,
2537                                           strlen(RealmName),
2538                                           RealmName,
2539                                           ServiceName,
2540                                           0);
2541
2542             if ( IsDebuggerPresent() ) {
2543                 char * cname, *sname;
2544                 pkrb5_unparse_name(ctx, increds.client, &cname);
2545                 pkrb5_unparse_name(ctx, increds.server, &sname);
2546                 OutputDebugString("krb5_get_credentials() returned Service Principal Unknown\n");
2547                 OutputDebugString("Trying again: getting tickets for \"");
2548                 OutputDebugString(cname);
2549                 OutputDebugString("\" and service \"");
2550                 OutputDebugString(sname);
2551                 OutputDebugString("\"\n");
2552                 pkrb5_free_unparsed_name(ctx,cname);
2553                 pkrb5_free_unparsed_name(ctx,sname);
2554             }
2555
2556             if (!code)
2557                 code = pkrb5_get_credentials(ctx, 0, cc, &increds, &k5creds);
2558         }
2559
2560         if ((code == KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN ||
2561               code == KRB5KRB_ERR_GENERIC /* heimdal */ ||
2562                           code == KRB5KRB_AP_ERR_MSG_TYPE) &&
2563              strcmp(RealmName, realm_of_cell)) {
2564             /* Or service/cell@REALM_OF_CELL */
2565             strcpy(RealmName, realm_of_cell);
2566             pkrb5_free_principal(ctx,increds.server);
2567             increds.server = 0;
2568             code = pkrb5_build_principal(ctx, &increds.server,
2569                                          strlen(RealmName),
2570                                          RealmName,
2571                                          ServiceName,
2572                                          CellName,
2573                                          0);
2574
2575             if ( IsDebuggerPresent() ) {
2576                 char * cname, *sname;
2577                 pkrb5_unparse_name(ctx, increds.client, &cname);
2578                 pkrb5_unparse_name(ctx, increds.server, &sname);
2579                 OutputDebugString("krb5_get_credentials() returned Service Principal Unknown\n");
2580                 OutputDebugString("Trying again: getting tickets for \"");
2581                 OutputDebugString(cname);
2582                 OutputDebugString("\" and service \"");
2583                 OutputDebugString(sname);
2584                 OutputDebugString("\"\n");
2585                 pkrb5_free_unparsed_name(ctx,cname);
2586                 pkrb5_free_unparsed_name(ctx,sname);
2587             }
2588
2589             if (!code)
2590                 code = pkrb5_get_credentials(ctx, 0, cc, &increds, &k5creds);
2591
2592
2593             if (code == KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN ||
2594                  code == KRB5KRB_ERR_GENERIC /* heimdal */ ||
2595                                  code == KRB5KRB_AP_ERR_MSG_TYPE) {
2596                 /* Or service@REALM_OF_CELL */
2597                 pkrb5_free_principal(ctx,increds.server);
2598                 increds.server = 0;
2599                 code = pkrb5_build_principal(ctx, &increds.server,
2600                                               strlen(RealmName),
2601                                               RealmName,
2602                                               ServiceName,
2603                                               0);
2604
2605                 if ( IsDebuggerPresent() ) {
2606                     char * cname, *sname;
2607                     pkrb5_unparse_name(ctx, increds.client, &cname);
2608                     pkrb5_unparse_name(ctx, increds.server, &sname);
2609                     OutputDebugString("krb5_get_credentials() returned Service Principal Unknown\n");
2610                     OutputDebugString("Trying again: getting tickets for \"");
2611                     OutputDebugString(cname);
2612                     OutputDebugString("\" and service \"");
2613                     OutputDebugString(sname);
2614                     OutputDebugString("\"\n");
2615                     pkrb5_free_unparsed_name(ctx,cname);
2616                     pkrb5_free_unparsed_name(ctx,sname);
2617                 }
2618
2619                 if (!code)
2620                     code = pkrb5_get_credentials(ctx, 0, cc, &increds, &k5creds);
2621             }
2622         }
2623
2624         if (code) {
2625             if ( IsDebuggerPresent() ) {
2626                 char message[256];
2627                 sprintf(message,"krb5_get_credentials returns: %d\n",code);
2628                 OutputDebugString(message);
2629             }
2630             try_krb5 = 0;
2631             goto use_krb4;
2632         }
2633
2634         /* This code inserts the entire K5 ticket into the token
2635          * No need to perform a krb524 translation which is
2636          * commented out in the code below
2637          */
2638         if (k5creds->ticket.length > MAXKTCTICKETLEN)
2639             goto try_krb524d;
2640
2641         memset(&aserver, '\0', sizeof(aserver));
2642         strncpy(aserver.name, ServiceName, MAXKTCNAMELEN - 1);
2643         strncpy(aserver.cell, CellName, MAXKTCREALMLEN - 1);
2644
2645         memset(&atoken, '\0', sizeof(atoken));
2646         atoken.kvno = RXKAD_TKT_TYPE_KERBEROS_V5;
2647         atoken.startTime = k5creds->times.starttime;
2648         atoken.endTime = k5creds->times.endtime;
2649         memcpy(&atoken.sessionKey, k5creds->keyblock.contents, k5creds->keyblock.length);
2650         atoken.ticketLen = k5creds->ticket.length;
2651         memcpy(atoken.ticket, k5creds->ticket.data, atoken.ticketLen);
2652
2653       retry_gettoken5:
2654         rc = ktc_GetToken(&aserver, &btoken, sizeof(btoken), &aclient);
2655         if (rc != 0 && rc != KTC_NOENT && rc != KTC_NOCELL) {
2656             if ( rc == KTC_NOCM && retry < 20 ) {
2657                 Sleep(500);
2658                 retry++;
2659                 goto retry_gettoken5;
2660             }
2661             goto try_krb524d;
2662         }
2663
2664         if (atoken.kvno == btoken.kvno &&
2665              atoken.ticketLen == btoken.ticketLen &&
2666              !memcmp(&atoken.sessionKey, &btoken.sessionKey, sizeof(atoken.sessionKey)) &&
2667              !memcmp(atoken.ticket, btoken.ticket, atoken.ticketLen))
2668         {
2669             /* Success - Nothing to do */
2670             goto cleanup;
2671         }
2672
2673         // * Reset the "aclient" structure before we call ktc_SetToken.
2674         // * This structure was first set by the ktc_GetToken call when
2675         // * we were comparing whether identical tokens already existed.
2676
2677         len = min(k5creds->client->data[0].length,MAXKTCNAMELEN - 1);
2678         strncpy(aclient.name, k5creds->client->data[0].data, len);
2679         aclient.name[len] = '\0';
2680
2681         if ( k5creds->client->length > 1 ) {
2682             char * p;
2683             strcat(aclient.name, ".");
2684             p = aclient.name + strlen(aclient.name);
2685             len = min(k5creds->client->data[1].length,MAXKTCNAMELEN - strlen(aclient.name) - 1);
2686             strncpy(p, k5creds->client->data[1].data, len);
2687             p[len] = '\0';
2688         }
2689         aclient.instance[0] = '\0';
2690
2691         strcpy(aclient.cell, realm_of_cell);
2692
2693         len = min(k5creds->client->realm.length,strlen(realm_of_cell));
2694         if ( strncmp(realm_of_cell, k5creds->client->realm.data, len) ) {
2695             char * p;
2696             strcat(aclient.name, "@");
2697             p = aclient.name + strlen(aclient.name);
2698             len = min(k5creds->client->realm.length,MAXKTCNAMELEN - strlen(aclient.name) - 1);
2699             strncpy(p, k5creds->client->realm.data, len);
2700             p[len] = '\0';
2701         }
2702
2703         if ( smbname ) {
2704             strncpy(aclient.smbname, smbname, MAXRANDOMNAMELEN);
2705             aclient.smbname[MAXRANDOMNAMELEN-1] = '\0';
2706         } else {
2707             aclient.smbname[0] = '\0';
2708         }
2709
2710         rc = ktc_SetToken(&aserver, &atoken, &aclient, 0);
2711         if (!rc)
2712             goto cleanup;   /* We have successfully inserted the token */
2713
2714       try_krb524d:
2715         /* Otherwise, the ticket could have been too large so try to
2716          * convert using the krb524d running with the KDC
2717          */
2718         code = pkrb524_convert_creds_kdc(ctx, k5creds, &creds);
2719         pkrb5_free_creds(ctx, k5creds);
2720         if (code) {
2721             if ( IsDebuggerPresent() ) {
2722                 char message[256];
2723                 sprintf(message,"krb524_convert_creds_kdc returns: %d\n",code);
2724                 OutputDebugString(message);
2725             }
2726             try_krb5 = 0;
2727             goto use_krb4;
2728         }
2729     } else {
2730       use_krb4:
2731 #ifdef USE_KRB4
2732         code = (*pkrb_get_cred)(ServiceName, CellName, RealmName, &creds);
2733         if (code == NO_TKT_FIL) {
2734             // if the problem is that we have no krb4 tickets
2735             // do not attempt to continue
2736             goto cleanup;
2737         }
2738         if (code != KSUCCESS)
2739             code = (*pkrb_get_cred)(ServiceName, "", RealmName, &creds);
2740
2741         if (code != KSUCCESS)
2742         {
2743             if ((code = (*pkrb_mk_req)(&ticket, ServiceName, CellName, RealmName, 0)) == KSUCCESS)
2744             {
2745                 if ((code = (*pkrb_get_cred)(ServiceName, CellName, RealmName, &creds)) != KSUCCESS)
2746                 {
2747                     goto cleanup;
2748                 }
2749             }
2750             else if ((code = (*pkrb_mk_req)(&ticket, ServiceName, "", RealmName, 0)) == KSUCCESS)
2751             {
2752                 if ((code = (*pkrb_get_cred)(ServiceName, "", RealmName, &creds)) != KSUCCESS)
2753                 {
2754                     goto cleanup;
2755                 }
2756             }
2757             else
2758             {
2759                 goto cleanup;
2760             }
2761         }
2762 #else
2763         goto cleanup;
2764 #endif
2765     }
2766
2767     memset(&aserver, '\0', sizeof(aserver));
2768     strncpy(aserver.name, ServiceName, MAXKTCNAMELEN - 1);
2769     strncpy(aserver.cell, CellName, MAXKTCREALMLEN - 1);
2770
2771     memset(&atoken, '\0', sizeof(atoken));
2772     atoken.kvno = creds.kvno;
2773     atoken.startTime = creds.issue_date;
2774     atoken.endTime = creds.issue_date + life_to_time(0,creds.lifetime);
2775     memcpy(&atoken.sessionKey, creds.session, 8);
2776     atoken.ticketLen = creds.ticket_st.length;
2777     memcpy(atoken.ticket, creds.ticket_st.dat, atoken.ticketLen);
2778
2779   retry_gettoken:
2780     rc = ktc_GetToken(&aserver, &btoken, sizeof(btoken), &aclient);
2781     if (rc != 0 && rc != KTC_NOENT && rc != KTC_NOCELL) {
2782         if ( rc == KTC_NOCM && retry < 20 ) {
2783             Sleep(500);
2784             retry++;
2785             goto retry_gettoken;
2786         }
2787         KFW_AFS_error(rc, "ktc_GetToken()");
2788         code = rc;
2789         goto cleanup;
2790     }
2791
2792     if (atoken.kvno == btoken.kvno &&
2793         atoken.ticketLen == btoken.ticketLen &&
2794         !memcmp(&atoken.sessionKey, &btoken.sessionKey, sizeof(atoken.sessionKey)) &&
2795         !memcmp(atoken.ticket, btoken.ticket, atoken.ticketLen))
2796     {
2797         goto cleanup;
2798     }
2799
2800     // * Reset the "aclient" structure before we call ktc_SetToken.
2801     // * This structure was first set by the ktc_GetToken call when
2802     // * we were comparing whether identical tokens already existed.
2803
2804     strncpy(aclient.name, creds.pname, MAXKTCNAMELEN - 1);
2805     if (creds.pinst[0])
2806     {
2807         strncat(aclient.name, ".", MAXKTCNAMELEN - 1);
2808         strncat(aclient.name, creds.pinst, MAXKTCNAMELEN - 1);
2809     }
2810     strcpy(aclient.instance, "");
2811
2812     if ( strcmp(realm_of_cell, creds.realm) )
2813     {
2814         strncat(aclient.name, "@", MAXKTCNAMELEN - 1);
2815         strncpy(aclient.name, creds.realm, MAXKTCREALMLEN - 1);
2816     }
2817     aclient.name[MAXKTCREALMLEN-1] = '\0';
2818
2819     strcpy(aclient.cell, CellName);
2820
2821     if ( smbname ) {
2822         strncpy(aclient.smbname, smbname, MAXRANDOMNAMELEN);
2823         aclient.smbname[MAXRANDOMNAMELEN-1] = '\0';
2824     } else {
2825         aclient.smbname[0] = '\0';
2826     }
2827
2828     if (rc = ktc_SetToken(&aserver, &atoken, &aclient, 0))
2829     {
2830         KFW_AFS_error(rc, "ktc_SetToken()");
2831         code = rc;
2832         goto cleanup;
2833     }
2834
2835   cleanup:
2836     if (client_principal)
2837         pkrb5_free_principal(ctx,client_principal);
2838     /* increds.client == client_principal */
2839     if (increds.server)
2840         pkrb5_free_principal(ctx,increds.server);
2841     if (cc && (cc != alt_cc))
2842         pkrb5_cc_close(ctx, cc);
2843     if (ctx && (ctx != alt_ctx))
2844         pkrb5_free_context(ctx);
2845
2846         return(rc? rc : code);
2847 }
2848
2849 /**************************************/
2850 /* afs_realm_of_cell():               */
2851 /**************************************/
2852 static char *
2853 afs_realm_of_cell(krb5_context ctx, struct afsconf_cell *cellconfig)
2854 {
2855     static char krbrlm[REALM_SZ+1]="";
2856     char ** realmlist=NULL;
2857     krb5_error_code r;
2858
2859     if (!cellconfig)
2860         return 0;
2861
2862     r = pkrb5_get_host_realm(ctx, cellconfig->hostName[0], &realmlist);
2863     if ( !r && realmlist && realmlist[0] ) {
2864         strcpy(krbrlm, realmlist[0]);
2865         pkrb5_free_host_realm(ctx, realmlist);
2866     }
2867
2868     if ( !krbrlm[0] )
2869     {
2870         char *s = krbrlm;
2871         char *t = cellconfig->name;
2872         int c;
2873
2874         while (c = *t++)
2875         {
2876             if (islower(c)) c=toupper(c);
2877             *s++ = c;
2878         }
2879         *s++ = 0;
2880     }
2881     return(krbrlm);
2882 }
2883
2884 /**************************************/
2885 /* KFW_AFS_get_cellconfig():          */
2886 /**************************************/
2887 int
2888 KFW_AFS_get_cellconfig(char *cell, struct afsconf_cell *cellconfig, char *local_cell)
2889 {
2890     int rc;
2891     char newcell[MAXCELLCHARS+1];
2892
2893     local_cell[0] = (char)0;
2894     memset(cellconfig, 0, sizeof(*cellconfig));
2895
2896     /* WIN32: cm_GetRootCellName(local_cell) - NOTE: no way to get max chars */
2897     if (rc = cm_GetRootCellName(local_cell))
2898     {
2899         return(rc);
2900     }
2901
2902     if (strlen(cell) == 0)
2903         strcpy(cell, local_cell);
2904
2905     /* WIN32: cm_SearchCellFile(cell, pcallback, pdata) */
2906     strcpy(cellconfig->name, cell);
2907
2908     rc = cm_SearchCellFile(cell, newcell, get_cellconfig_callback, (void*)cellconfig);
2909 #ifdef AFS_AFSDB_ENV
2910     if (rc != 0) {
2911         int ttl;
2912         rc = cm_SearchCellByDNS(cell, newcell, &ttl, get_cellconfig_callback, (void*)cellconfig);
2913     }
2914 #endif
2915     return rc;
2916 }
2917
2918 /**************************************/
2919 /* get_cellconfig_callback():         */
2920 /**************************************/
2921 static long
2922 get_cellconfig_callback(void *cellconfig, struct sockaddr_in *addrp, char *namep)
2923 {
2924     struct afsconf_cell *cc = (struct afsconf_cell *)cellconfig;
2925
2926     cc->hostAddr[cc->numServers] = *addrp;
2927     strcpy(cc->hostName[cc->numServers], namep);
2928     cc->numServers++;
2929     return(0);
2930 }
2931
2932
2933 /**************************************/
2934 /* KFW_AFS_error():                  */
2935 /**************************************/
2936 void
2937 KFW_AFS_error(LONG rc, LPCSTR FailedFunctionName)
2938 {
2939     char message[256];
2940     const char *errText;
2941
2942     // Using AFS defines as error messages for now, until Transarc
2943     // gets back to me with "string" translations of each of these
2944     // const. defines.
2945     if (rc == KTC_ERROR)
2946       errText = "KTC_ERROR";
2947     else if (rc == KTC_TOOBIG)
2948       errText = "KTC_TOOBIG";
2949     else if (rc == KTC_INVAL)
2950       errText = "KTC_INVAL";
2951     else if (rc == KTC_NOENT)
2952       errText = "KTC_NOENT";
2953     else if (rc == KTC_PIOCTLFAIL)
2954       errText = "KTC_PIOCTLFAIL";
2955     else if (rc == KTC_NOPIOCTL)
2956       errText = "KTC_NOPIOCTL";
2957     else if (rc == KTC_NOCELL)
2958       errText = "KTC_NOCELL";
2959     else if (rc == KTC_NOCM)
2960       errText = "KTC_NOCM: The service, Transarc AFS Daemon, most likely is not started!";
2961     else
2962       errText = "Unknown error!";
2963
2964     sprintf(message, "%s (0x%x)\n(%s failed)", errText, rc, FailedFunctionName);
2965
2966     if ( IsDebuggerPresent() ) {
2967         OutputDebugString(message);
2968         OutputDebugString("\n");
2969     }
2970     MessageBox(NULL, message, "AFS", MB_OK | MB_ICONERROR | MB_TASKMODAL | MB_SETFOREGROUND);
2971     return;
2972 }
2973
2974 static DWORD
2975 GetServiceStatus(
2976     LPSTR lpszMachineName,
2977     LPSTR lpszServiceName,
2978     DWORD *lpdwCurrentState)
2979 {
2980     DWORD           hr               = NOERROR;
2981     SC_HANDLE       schSCManager     = NULL;
2982     SC_HANDLE       schService       = NULL;
2983     DWORD           fdwDesiredAccess = 0;
2984     SERVICE_STATUS  ssServiceStatus  = {0};
2985     BOOL            fRet             = FALSE;
2986
2987     *lpdwCurrentState = 0;
2988
2989     fdwDesiredAccess = GENERIC_READ;
2990
2991     schSCManager = OpenSCManager(lpszMachineName,
2992                                  NULL,
2993                                  fdwDesiredAccess);
2994
2995     if(schSCManager == NULL)
2996     {
2997         hr = GetLastError();
2998         goto cleanup;
2999     }
3000
3001     schService = OpenService(schSCManager,
3002                              lpszServiceName,
3003                              fdwDesiredAccess);
3004
3005     if(schService == NULL)
3006     {
3007         hr = GetLastError();
3008         goto cleanup;
3009     }
3010
3011     fRet = QueryServiceStatus(schService,
3012                               &ssServiceStatus);
3013
3014     if(fRet == FALSE)
3015     {
3016         hr = GetLastError();
3017         goto cleanup;
3018     }
3019
3020     *lpdwCurrentState = ssServiceStatus.dwCurrentState;
3021
3022 cleanup:
3023
3024     CloseServiceHandle(schService);
3025     CloseServiceHandle(schSCManager);
3026
3027     return(hr);
3028 }
3029
3030 void
3031 UnloadFuncs(
3032     FUNC_INFO fi[],
3033     HINSTANCE h
3034     )
3035 {
3036     int n;
3037     if (fi)
3038         for (n = 0; fi[n].func_ptr_var; n++)
3039             *(fi[n].func_ptr_var) = 0;
3040     if (h) FreeLibrary(h);
3041 }
3042
3043 int
3044 LoadFuncs(
3045     const char* dll_name,
3046     FUNC_INFO fi[],
3047     HINSTANCE* ph,  // [out, optional] - DLL handle
3048     int* pindex,    // [out, optional] - index of last func loaded (-1 if none)
3049     int cleanup,    // cleanup function pointers and unload on error
3050     int go_on,      // continue loading even if some functions cannot be loaded
3051     int silent      // do not pop-up a system dialog if DLL cannot be loaded
3052     )
3053 {
3054     HINSTANCE h;
3055     int i, n, last_i;
3056     int error = 0;
3057     UINT em;
3058
3059     if (ph) *ph = 0;
3060     if (pindex) *pindex = -1;
3061
3062     for (n = 0; fi[n].func_ptr_var; n++)
3063         *(fi[n].func_ptr_var) = 0;
3064
3065     if (silent)
3066         em = SetErrorMode(SEM_FAILCRITICALERRORS);
3067     h = LoadLibrary(dll_name);
3068     if (silent)
3069         SetErrorMode(em);
3070
3071     if (!h)
3072         return 0;
3073
3074     last_i = -1;
3075     for (i = 0; (go_on || !error) && (i < n); i++)
3076     {
3077         void* p = (void*)GetProcAddress(h, fi[i].func_name);
3078         if (!p)
3079             error = 1;
3080         else
3081         {
3082             last_i = i;
3083             *(fi[i].func_ptr_var) = p;
3084         }
3085     }
3086     if (pindex) *pindex = last_i;
3087     if (error && cleanup && !go_on) {
3088         for (i = 0; i < n; i++) {
3089             *(fi[i].func_ptr_var) = 0;
3090         }
3091         FreeLibrary(h);
3092         return 0;
3093     }
3094     if (ph) *ph = h;
3095     if (error) return 0;
3096     return 1;
3097 }
3098
3099 BOOL KFW_probe_kdc(struct afsconf_cell * cellconfig)
3100 {
3101     krb5_context ctx = 0;
3102     krb5_ccache cc = 0;
3103     krb5_error_code code;
3104     krb5_data pwdata;
3105     const char * realm = 0;
3106     krb5_principal principal = 0;
3107     char * pname = 0;
3108     char   password[PROBE_PASSWORD_LEN+1];
3109     BOOL serverReachable = 0;
3110
3111     if (!pkrb5_init_context)
3112         return 0;
3113
3114     code = pkrb5_init_context(&ctx);
3115     if (code) goto cleanup;
3116
3117
3118     realm = afs_realm_of_cell(ctx, cellconfig);  // do not free
3119
3120     code = pkrb5_build_principal(ctx, &principal, strlen(realm),
3121                                   realm, PROBE_USERNAME, NULL, NULL);
3122     if ( code ) goto cleanup;
3123
3124     code = KFW_get_ccache(ctx, principal, &cc);
3125     if ( code ) goto cleanup;
3126
3127     code = pkrb5_unparse_name(ctx, principal, &pname);
3128     if ( code ) goto cleanup;
3129
3130     pwdata.data = password;
3131     pwdata.length = PROBE_PASSWORD_LEN;
3132     code = pkrb5_c_random_make_octets(ctx, &pwdata);
3133     if (code) {
3134         int i;
3135         for ( i=0 ; i<PROBE_PASSWORD_LEN ; i++ )
3136             password[i] = 'x';
3137     }
3138     password[PROBE_PASSWORD_LEN] = '\0';
3139
3140     code = KFW_kinit(NULL, NULL, HWND_DESKTOP,
3141                       pname,
3142                       password,
3143                       5,
3144                       0,
3145                       0,
3146                       0,
3147                       1,
3148                       0);
3149     switch ( code ) {
3150     case KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN:
3151     case KRB5KDC_ERR_CLIENT_REVOKED:
3152     case KRB5KDC_ERR_CLIENT_NOTYET:
3153     case KRB5KDC_ERR_PREAUTH_FAILED:
3154     case KRB5KDC_ERR_PREAUTH_REQUIRED:
3155     case KRB5KDC_ERR_PADATA_TYPE_NOSUPP:
3156         serverReachable = TRUE;
3157         break;
3158     default:
3159         serverReachable = FALSE;
3160     }
3161
3162   cleanup:
3163     if ( pname )
3164         pkrb5_free_unparsed_name(ctx,pname);
3165     if ( principal )
3166         pkrb5_free_principal(ctx,principal);
3167     if (cc)
3168         pkrb5_cc_close(ctx,cc);
3169     if (ctx)
3170         pkrb5_free_context(ctx);
3171
3172     return serverReachable;
3173 }
3174