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