9a1a31d3328bc8bb107ab8684cd9c1bbc0550997
[openafs.git] / src / WINNT / client_creds / window.cpp
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 extern "C" {
11 #include <afs/param.h>
12 #include <afs/stds.h>
13 #include <afs/afskfw.h>
14 #include "ipaddrchg.h"
15 }
16
17 #include "afscreds.h"
18
19 /*
20  * DEFINITIONS ________________________________________________________________
21  *
22  */
23
24 #define ID_REMIND_TIMER      1000
25 #define ID_SERVICE_TIMER     1001
26
27 #define cREALLOC_TABS        4
28
29 #define dwTABPARAM_MOUNT     (LPTSTR)0
30 #define dwTABPARAM_ADVANCED  (LPTSTR)1
31 #define ISCELLTAB(_psz)      ((HIWORD((LONG)(_psz))) != 0)
32
33
34 /*
35  * PROTOTYPES _________________________________________________________________
36  *
37  */
38
39 void Main_OnInitDialog (HWND hDlg);
40 void Main_OnCheckMenuRemind (void);
41 void Main_OnRemindTimer (void);
42 void Main_OnMouseOver (void);
43 void Main_OnSelectTab (void);
44 void Main_OnCheckTerminate (void);
45 HWND Main_CreateTabDialog (HWND hTab, size_t iTab);
46
47 BOOL CALLBACK Terminate_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp);
48 void Terminate_OnInitDialog (HWND hDlg);
49 void Terminate_OnOK (HWND hDlg);
50
51
52 /*
53  * ROUTINES ___________________________________________________________________
54  *
55  */
56
57 BOOL CALLBACK Main_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
58 {
59    static UINT msgCheckTerminate = 0;
60    if (msgCheckTerminate == 0)
61       msgCheckTerminate = RegisterWindowMessage (TEXT("AfsCredsCheckTerminate"));
62
63    if (msg == msgCheckTerminate)
64       {
65       Main_OnCheckTerminate();
66       }
67    else switch (msg)
68       {
69       case WM_INITDIALOG:
70          g.hMain = hDlg;
71          Main_OnInitDialog (hDlg);
72          break;
73
74       case WM_DESTROY:
75          Creds_CloseLibraries();
76          ChangeTrayIcon (NIM_DELETE);
77          break;
78
79       case WM_ACTIVATEAPP:
80          if (wp)
81             {
82             Main_RepopulateTabs (FALSE);
83             }
84          break;
85
86       case WM_COMMAND:
87          switch (LOWORD(wp))
88             {
89             case IDOK:
90             case IDCANCEL:
91                Main_Show (FALSE);
92                break;
93
94             case M_ACTIVATE:
95                if (g.fIsWinNT || IsServiceRunning())
96                   {
97                   if (!lp) // Got here from "/show" parameter? switch tabs.
98                      {
99                      HWND hTab = GetDlgItem (g.hMain, IDC_TABS);
100                      TabCtrl_SetCurSel (hTab, 0);
101                      Main_OnSelectTab();
102                      }
103                   Main_Show (TRUE);
104                   }
105                else
106                   {
107                   Message (MB_ICONHAND, IDS_UNCONFIG_TITLE_95, IDS_UNCONFIG_DESC_95);
108                   }
109                break;
110
111             case M_TERMINATE:
112                if (g.fIsWinNT && IsServiceRunning())
113                   ModalDialog (IDD_TERMINATE, NULL, (DLGPROC)Terminate_DlgProc);
114                else if (g.fIsWinNT)
115                   ModalDialog (IDD_TERMINATE_SMALL, NULL, (DLGPROC)Terminate_DlgProc);
116                else // (!g.fIsWinNT)
117                   ModalDialog (IDD_TERMINATE_SMALL_95, NULL, (DLGPROC)Terminate_DlgProc);
118                break;
119
120             case M_TERMINATE_NOW:
121                Quit();
122                break;
123
124             case M_REMIND:
125                Main_OnCheckMenuRemind();
126                break;
127             }
128          break;
129
130       case WM_TIMER:
131          Main_OnRemindTimer();
132          break;
133
134       case WM_NOTIFY:
135          switch (((NMHDR*)lp)->code)
136             {
137             case TCN_SELCHANGE:
138                Main_OnSelectTab();
139                break;
140             }
141          break;
142
143       case WM_TRAYICON:
144          switch (lp)
145             {
146             case WM_LBUTTONDOWN:
147                if (IsServiceRunning() || !IsServiceConfigured())
148                   Main_Show (TRUE);
149                else if (!g.fIsWinNT)
150                   Message (MB_ICONHAND, IDS_UNCONFIG_TITLE_95, IDS_UNCONFIG_DESC_95);
151                else
152                   ShowStartupWizard();
153                break;
154
155             case WM_RBUTTONDOWN:
156                HMENU hm;
157                if ((hm = TaLocale_LoadMenu (MENU_TRAYICON)) != 0)
158                   {
159                   POINT pt;
160                   GetCursorPos(&pt);
161
162                   HMENU hmDummy = CreateMenu();
163                   InsertMenu (hmDummy, 0, MF_POPUP, (UINT)hm, NULL);
164
165                   BOOL fRemind = FALSE;
166                   lock_ObtainMutex(&g.credsLock);
167                   for (size_t iCreds = 0; iCreds < g.cCreds; ++iCreds)
168                      {
169                      if (g.aCreds[ iCreds ].fRemind)
170                         fRemind = TRUE;
171                      }
172                   lock_ReleaseMutex(&g.credsLock);
173                   CheckMenuItem (hm, M_REMIND, MF_BYCOMMAND | ((fRemind) ? MF_CHECKED : MF_UNCHECKED));
174
175                   TrackPopupMenu (GetSubMenu (hmDummy, 0),
176                                   TPM_RIGHTALIGN | TPM_RIGHTBUTTON,
177                                   pt.x, pt.y, NULL, hDlg, NULL);
178
179                   DestroyMenu (hmDummy);
180                   }
181                break;
182
183             case WM_MOUSEMOVE:
184                Main_OnMouseOver();
185                break;
186             }
187          break;
188       case WM_OBTAIN_TOKENS:
189           if ( InterlockedIncrement (&g.fShowingMessage) != 1 )
190               InterlockedDecrement (&g.fShowingMessage);
191           else
192               ShowObtainCreds (wp, (char *)lp);
193           GlobalFree((void *)lp);
194           break;
195
196       case WM_START_SERVICE:
197           {
198               SC_HANDLE hManager;
199               if ((hManager = OpenSCManager ( NULL, NULL, 
200                                               SC_MANAGER_CONNECT |
201                                               SC_MANAGER_ENUMERATE_SERVICE |
202                                               SC_MANAGER_QUERY_LOCK_STATUS)) != NULL)
203               {
204                   SC_HANDLE hService;
205                   if ((hService = OpenService ( hManager, TEXT("TransarcAFSDaemon"), 
206                                                 SERVICE_QUERY_STATUS | SERVICE_START)) != NULL)
207                   {
208                       if (StartService (hService, 0, 0))
209                           TestAndDoMapShare(SERVICE_START_PENDING);
210                                   if ( KFW_is_available() && KFW_AFS_wait_for_service_start() ) {
211 #ifdef USE_MS2MIT
212                               KFW_import_windows_lsa();
213 #endif /* USE_MS2MIT */
214                                           KFW_AFS_renew_tokens_for_all_cells();
215                                                   }
216
217                       CloseServiceHandle (hService);
218                   }
219
220                   CloseServiceHandle (hManager);
221               }
222               KFW_AFS_wait_for_service_start();
223               ObtainTokensFromUserIfNeeded(g.hMain);
224           }
225           break;
226       }
227
228    return FALSE;
229 }
230
231
232 void Main_Show (BOOL fShow)
233 {
234    if (fShow)
235       {
236       ShowWindow (g.hMain, SW_SHOW);
237       SetWindowPos (g.hMain, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
238       SetForegroundWindow (g.hMain);
239       }
240    else
241       {
242       SetWindowPos (g.hMain, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW);
243       }
244 }
245
246
247 void Main_OnInitDialog (HWND hDlg)
248 {
249    if (!g.fIsWinNT)
250       {
251       TCHAR szTitle[256];
252       GetString (szTitle, IDS_TITLE_95);
253       SetWindowText (hDlg, szTitle);
254       }
255
256    TCHAR szVersion[256];
257    DWORD dwPatch = 0;
258    TCHAR szUser[256];
259    GetString (szVersion, IDS_UNKNOWN);
260    GetString (szUser, IDS_UNKNOWN);
261
262    HKEY hk;
263    if (RegOpenKey (HKEY_LOCAL_MACHINE, REGSTR_PATH_AFS, &hk) == 0)
264       {
265       DWORD dwSize = sizeof(szVersion);
266       DWORD dwType = REG_SZ;
267       RegQueryValueEx (hk, REGVAL_AFS_VERSION, NULL, &dwType, (PBYTE)szVersion, &dwSize);
268
269       dwSize = sizeof(dwPatch);
270       dwType = REG_DWORD;
271       RegQueryValueEx (hk, REGVAL_AFS_PATCH, NULL, &dwType, (PBYTE)&dwPatch, &dwSize);
272       RegCloseKey (hk);
273       }
274
275    BOOL fFoundUserName = FALSE;
276     if (RegOpenKey (HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Explorer"), &hk) == 0)
277     {
278         DWORD dwSize = sizeof(szUser);
279         DWORD dwType = REG_SZ;
280         if (RegQueryValueEx (hk, TEXT("Logon User Name"), NULL, &dwType, (PBYTE)szUser, &dwSize) == 0)
281             fFoundUserName = TRUE;
282         RegCloseKey (hk);
283     }
284     if (!fFoundUserName ) 
285     {
286         if (RegOpenKey (HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"), &hk) == 0)
287         {
288             DWORD dwSize = sizeof(szUser);
289             DWORD dwType = REG_SZ;
290             if (RegQueryValueEx (hk, TEXT("DefaultUserName"), NULL, &dwType, (PBYTE)szUser, &dwSize) == 0)
291                 fFoundUserName = TRUE;
292             RegCloseKey (hk);
293         }
294     }
295    if (!fFoundUserName)
296    {
297        if (RegOpenKey (HKEY_LOCAL_MACHINE, TEXT("Network\\Logon"), &hk) == 0)
298        {
299            DWORD dwSize = sizeof(szUser);
300            DWORD dwType = REG_SZ;
301            if (RegQueryValueEx (hk, TEXT("UserName"), NULL, &dwType, (PBYTE)szUser, &dwSize) == 0)
302                fFoundUserName = TRUE;
303            RegCloseKey (hk);
304        }
305    }
306
307    TCHAR szSource[ cchRESOURCE ];
308    TCHAR szTarget[ cchRESOURCE ];
309
310    GetString (szSource, (dwPatch) ? IDS_TITLE_VERSION : IDS_TITLE_VERSION_NOPATCH);
311    wsprintf (szTarget, szSource, szVersion, dwPatch);
312    SetDlgItemText (hDlg, IDC_TITLE_VERSION, szTarget);
313
314    GetDlgItemText (hDlg, IDC_TITLE_NT, szSource, cchRESOURCE);
315    wsprintf (szTarget, szSource, szUser);
316    SetDlgItemText (hDlg, IDC_TITLE_NT, szTarget);
317 }
318
319
320 void Main_OnCheckMenuRemind (void)
321 {
322    BOOL fRemind = FALSE;
323    lock_ObtainMutex(&g.credsLock);
324    for (size_t iCreds = 0; iCreds < g.cCreds; ++iCreds)
325       {
326       if (g.aCreds[ iCreds ].fRemind)
327          fRemind = TRUE;
328       }
329
330    fRemind = !fRemind;
331    for (iCreds = 0; iCreds < g.cCreds; ++iCreds)
332       {
333       if (g.aCreds[ iCreds ].fRemind != fRemind)
334          {
335          g.aCreds[ iCreds ].fRemind = fRemind;
336          SaveRemind (iCreds);
337          }
338       }
339    lock_ReleaseMutex(&g.credsLock);
340
341    // Check the active tab, and fix its checkbox if necessary
342    //
343    HWND hTab = GetDlgItem (g.hMain, IDC_TABS);
344    LPTSTR pszTab = (LPTSTR)GetTabParam (hTab, TabCtrl_GetCurSel(hTab));
345    if (ISCELLTAB(pszTab) && (*pszTab))
346       {
347       HWND hDlg = GetTabChild (hTab);
348       if (hDlg)
349          CheckDlgButton (hDlg, IDC_CREDS_REMIND, fRemind);
350       }
351
352    // Make sure the reminder timer is going
353    //
354    Main_EnableRemindTimer (fRemind);
355 }
356
357
358 void Main_OnRemindTimer (void)
359 {
360    Main_RepopulateTabs (TRUE);
361
362    // See if anything is close to expiring; if so, display a warning
363    // dialog. Make sure we never display a warning more than once.
364    //
365    size_t iExpired;
366    if ((iExpired = Main_FindExpiredCreds()) != -1)
367       {
368       if (InterlockedIncrement (&g.fShowingMessage) != 1)
369          InterlockedDecrement (&g.fShowingMessage);
370       else
371          ShowObtainCreds (TRUE, g.aCreds[ iExpired ].szCell);
372       }
373 }
374
375
376 void Main_OnMouseOver (void)
377 {
378    if ((GetTickCount() - g.tickLastRetest) > cmsecMOUSEOVER)
379       {
380       Main_RepopulateTabs (TRUE);
381       }
382 }
383
384
385 void Main_OnSelectTab (void)
386 {
387    HWND hTab = GetDlgItem (g.hMain, IDC_TABS);
388    size_t iTab = TabCtrl_GetCurSel (hTab);
389
390    HWND hDlgOld = GetTabChild (hTab);
391
392    HWND hDlgNew;
393    if ((hDlgNew = Main_CreateTabDialog (hTab, iTab)) != NULL)
394       ShowWindow (hDlgNew, SW_SHOW);
395
396    if (hDlgOld)
397       DestroyWindow (hDlgOld);
398 }
399
400
401 void Main_OnCheckTerminate (void)
402 {
403     HKEY hk;
404
405     if (RegOpenKey (HKEY_CURRENT_USER, REGSTR_PATH_OPENAFS_CLIENT, &hk) == 0)
406     {
407         DWORD dwSize = sizeof(g.fStartup);
408         DWORD dwType = REG_DWORD;
409         RegQueryValueEx (hk, TEXT("ShowTrayIcon"), NULL, &dwType, (PBYTE)&g.fStartup, &dwSize);
410         RegCloseKey (hk);
411     }
412     else if (RegOpenKey (HKEY_LOCAL_MACHINE, REGSTR_PATH_OPENAFS_CLIENT, &hk) == 0)
413     {
414       DWORD dwSize = sizeof(g.fStartup);
415       DWORD dwType = REG_DWORD;
416       RegQueryValueEx (hk, TEXT("ShowTrayIcon"), NULL, &dwType, (PBYTE)&g.fStartup, &dwSize);
417       RegCloseKey (hk);
418     }
419
420     Shortcut_FixStartup (cszSHORTCUT_NAME, g.fStartup);
421
422     if (!g.fStartup)
423         Quit();
424 }
425
426
427 HWND Main_CreateTabDialog (HWND hTab, size_t iTab)
428 {
429    HWND hDlg = NULL;
430    LPTSTR psz = NULL;
431
432    TC_ITEM Item;
433    memset (&Item, 0x00, sizeof(Item));
434    Item.mask = TCIF_PARAM;
435    if (TabCtrl_GetItem (hTab, iTab, &Item))
436       {
437       psz = (LPTSTR)(Item.lParam);
438       }
439
440    if (psz == dwTABPARAM_ADVANCED)    // Advanced tab
441       {
442       hDlg = ModelessDialog (IDD_TAB_ADVANCED, hTab, (DLGPROC)Advanced_DlgProc);
443       }
444    else if (psz == dwTABPARAM_MOUNT)  // Mount Points tab
445       {
446       hDlg = ModelessDialog (IDD_TAB_MOUNT, hTab, (DLGPROC)Mount_DlgProc);
447       }
448    else if (ISCELLTAB(psz) && !*psz)  // No Creds tab
449       {
450       hDlg = ModelessDialogParam (IDD_TAB_NOCREDS, hTab, (DLGPROC)Creds_DlgProc, (LPARAM)psz);
451       }
452    else if (ISCELLTAB(psz) && *psz)   // Creds tab for a particular cell
453       {
454       hDlg = ModelessDialogParam (IDD_TAB_CREDS, hTab, (DLGPROC)Creds_DlgProc, (LPARAM)psz);
455       }
456
457    return hDlg;
458 }
459
460
461 void Main_RepopulateTabs (BOOL fDestroyInvalid)
462 {
463    static BOOL fInHere = FALSE;
464    if (!fInHere)
465       {
466       fInHere = TRUE;
467
468       if (IsWindowVisible (g.hMain))
469          fDestroyInvalid = FALSE;
470
471       // First we'll have to look around and see what credentials we currently
472       // have. This call just updates g.aCreds[]; it doesn't do anything else.
473       //
474       (void)GetCurrentCredentials();
475
476       // We want one tab on the main dialog for each g.aCredentials entry,
477       // and one tab for Advanced.
478       //
479       HWND hTab = GetDlgItem (g.hMain, IDC_TABS);
480
481       // Generate a list of the lParams we'll be giving tabs...
482       //
483       LPTSTR *aTabs = NULL;
484       size_t cTabs = 0;
485       size_t iTabOut = 0;
486
487       size_t nCreds = 0;
488       lock_ObtainMutex(&g.credsLock);
489       for (size_t iCreds = 0; iCreds < g.cCreds; ++iCreds)
490          {
491          if (g.aCreds[ iCreds ].szCell[0])
492             ++nCreds;
493          }
494       if (!nCreds)
495          {
496          fDestroyInvalid = TRUE;
497          }
498
499       if (!fDestroyInvalid)
500          {
501          int nTabs = TabCtrl_GetItemCount(hTab);
502          for (int iTab = 0; iTab < nTabs; ++iTab)
503             {
504             LPTSTR pszTab = (LPTSTR)GetTabParam (hTab, iTab);
505             if (ISCELLTAB(pszTab) && (*pszTab))
506                {
507                if (REALLOC (aTabs, cTabs, 1+iTabOut, cREALLOC_TABS))
508                   aTabs[ iTabOut++ ] = CloneString(pszTab);
509                }
510             }
511          }
512
513       if (nCreds == 0)
514          {
515          if (REALLOC (aTabs, cTabs, 1+iTabOut, cREALLOC_TABS))
516             aTabs[ iTabOut++ ] = CloneString (TEXT(""));
517          }
518       else for (iCreds = 0; iCreds < g.cCreds; ++iCreds)
519          {
520          if (g.aCreds[ iCreds ].szCell[0])
521             {
522             for (size_t ii = 0; ii < iTabOut; ++ii)
523                {
524                if (!ISCELLTAB (aTabs[ii]))
525                   continue;
526                if (!lstrcmpi (g.aCreds[ iCreds ].szCell, aTabs[ ii ]))
527                   break;
528                }
529             if (ii == iTabOut)
530                {
531                if (REALLOC (aTabs, cTabs, 1+iTabOut, cREALLOC_TABS))
532                   aTabs[ iTabOut++ ] = CloneString (g.aCreds[ iCreds ].szCell);
533                }
534             }
535          }
536       lock_ReleaseMutex(&g.credsLock);
537
538       if (REALLOC (aTabs, cTabs, 1+iTabOut, cREALLOC_TABS))
539          aTabs[ iTabOut++ ] = dwTABPARAM_MOUNT;
540
541       if (g.fIsWinNT)
542          {
543          if (REALLOC (aTabs, cTabs, 1+iTabOut, cREALLOC_TABS))
544             aTabs[ iTabOut++ ] = dwTABPARAM_ADVANCED;
545          }
546
547       // Now erase the current tabs, and re-add new ones. Remember which tab is
548       // currently selected, so we can try to go back to it later.
549       //
550       int iTabSel = 0;
551       if (TabCtrl_GetItemCount(hTab))
552          {
553          LPTSTR pszTabSel = (LPTSTR)GetTabParam (hTab, TabCtrl_GetCurSel(hTab));
554          for (size_t iSel = 0; iSel < iTabOut; ++iSel)
555             {
556             if ((!ISCELLTAB(pszTabSel))  && (!ISCELLTAB(aTabs[iSel])) && (pszTabSel == aTabs[iSel]))
557                iTabSel = iSel;
558             else if (ISCELLTAB(pszTabSel) && ISCELLTAB(aTabs[iSel]) && !lstrcmpi (pszTabSel, aTabs[iSel]))
559                iTabSel = iSel;
560             }
561          }
562
563       int nTabs = TabCtrl_GetItemCount(hTab);
564       for (int iTab = 0; iTab < nTabs; ++iTab)
565          {
566          LPTSTR pszTab = (LPTSTR)GetTabParam (hTab, iTab);
567          if (ISCELLTAB(pszTab))
568             FreeString (pszTab);
569          }
570       TabCtrl_DeleteAllItems (hTab);
571
572       for (size_t ii = 0; ii < iTabOut; ++ii)
573          {
574          TCHAR szTitle[cchRESOURCE];
575          if (aTabs[ii] == dwTABPARAM_ADVANCED)
576             GetString (szTitle, IDS_ADVANCED);
577          else if (aTabs[ii] == dwTABPARAM_MOUNT)
578             GetString (szTitle, IDS_MOUNT);
579          else if ((nCreds <= 1) || (aTabs[ii][0] == TEXT('\0')))
580             GetString (szTitle, IDS_CREDENTIALS);
581          else
582             lstrcpy (szTitle, aTabs[ii]);
583
584          TC_ITEM Item;
585          memset (&Item, 0x00, sizeof(Item));
586          Item.mask = TCIF_PARAM | TCIF_TEXT;
587          Item.pszText = szTitle;
588          Item.cchTextMax = cchRESOURCE;
589          Item.lParam = (LPARAM)(aTabs[ii]);
590
591          TabCtrl_InsertItem (hTab, ii, &Item);
592          }
593
594       if (aTabs != NULL)
595          Free (aTabs);
596
597       TabCtrl_SetCurSel (hTab, iTabSel);
598       Main_OnSelectTab ();
599
600       fInHere = FALSE;
601       }
602 }
603
604
605 void Main_EnableRemindTimer (BOOL fEnable)
606 {
607    static BOOL bEnabled = FALSE;
608
609    if ( fEnable == FALSE && bEnabled == TRUE ) {
610        KillTimer (g.hMain, ID_REMIND_TIMER);
611        bEnabled = FALSE;
612    } else if ( fEnable == TRUE && bEnabled == FALSE ) {
613       SetTimer (g.hMain, ID_REMIND_TIMER, (ULONG)cmsec1MINUTE * cminREMIND_TEST, NULL);
614       bEnabled = TRUE;
615    }
616 }
617
618
619 size_t Main_FindExpiredCreds (void)
620 {
621    size_t retval = (size_t) -1;
622    lock_ObtainMutex(&g.expirationCheckLock);
623    if ( KFW_is_available() )
624        KFW_AFS_renew_expiring_tokens();
625    lock_ObtainMutex(&g.credsLock);
626    for (size_t iCreds = 0; iCreds < g.cCreds; ++iCreds)
627       {
628       if (!g.aCreds[ iCreds ].szCell[0])
629          continue;
630       if (!g.aCreds[ iCreds ].fRemind)
631          continue;
632
633       SYSTEMTIME stNow;
634       GetLocalTime (&stNow);
635
636       FILETIME ftNow;
637       SystemTimeToFileTime (&stNow, &ftNow);
638
639       FILETIME ftExpires;
640       SystemTimeToFileTime (&g.aCreds[ iCreds ].stExpires, &ftExpires);
641
642       LONGLONG llNow = (((LONGLONG)ftNow.dwHighDateTime) << 32) + (LONGLONG)(ftNow.dwLowDateTime);
643       LONGLONG llExpires = (((LONGLONG)ftExpires.dwHighDateTime) << 32) + (LONGLONG)(ftExpires.dwLowDateTime);
644
645       llNow /= c100ns1SECOND;
646       llExpires /= c100ns1SECOND;
647
648       if (llExpires <= (llNow + (LONGLONG)cminREMIND_WARN * csec1MINUTE))
649          {
650          if ( KFW_is_available() &&
651               KFW_AFS_renew_token_for_cell(g.aCreds[ iCreds ].szCell) )
652              continue;
653          retval = (size_t) iCreds;
654          break;
655          }
656       }
657    
658    lock_ReleaseMutex(&g.credsLock);
659    lock_ReleaseMutex(&g.expirationCheckLock);
660
661    return retval;
662 }
663
664
665 BOOL CALLBACK Terminate_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
666 {
667    switch (msg)
668       {
669       case WM_INITDIALOG:
670          Terminate_OnInitDialog (hDlg);
671          break;
672
673       case WM_COMMAND:
674          switch (LOWORD(wp))
675             {
676             case IDOK:
677                Terminate_OnOK (hDlg);
678                break;
679
680             case IDCANCEL:
681                EndDialog (hDlg, IDCANCEL);
682                break;
683             }
684          break;
685       }
686
687    return FALSE;
688 }
689
690
691 void Terminate_OnInitDialog (HWND hDlg)
692 {
693    BOOL fPersistent = IsServicePersistent();
694
695    CheckDlgButton (hDlg, IDC_STARTUP, g.fStartup);
696    CheckDlgButton (hDlg, IDC_LEAVE, fPersistent);
697    CheckDlgButton (hDlg, IDC_STOP, !fPersistent);
698 }
699
700
701 void Terminate_OnOK (HWND hDlg)
702 {
703    if (IsServiceRunning())
704       {
705       if (IsDlgButtonChecked (hDlg, IDC_STOP))
706          {
707          SC_HANDLE hManager;
708              if ((hManager = OpenSCManager (NULL, NULL, 
709                                             SC_MANAGER_CONNECT |
710                                             SC_MANAGER_ENUMERATE_SERVICE |
711                                             SC_MANAGER_QUERY_LOCK_STATUS)) != NULL)
712             {
713             SC_HANDLE hService;
714             if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), 
715                                          SERVICE_QUERY_STATUS | SERVICE_START)) != NULL)
716                {
717                SERVICE_STATUS Status;
718                ControlService (hService, SERVICE_CONTROL_STOP, &Status);
719
720                CloseServiceHandle (hService);
721                }
722
723             CloseServiceHandle (hManager);
724             }
725          }
726       }
727
728    g.fStartup = IsDlgButtonChecked (hDlg, IDC_STARTUP);
729
730     HKEY hk;
731     if (RegCreateKey (HKEY_CURRENT_USER, REGSTR_PATH_OPENAFS_CLIENT, &hk) == 0)
732     {
733         DWORD dwSize = sizeof(g.fStartup);
734         DWORD dwType = REG_DWORD;
735         RegSetValueEx (hk, TEXT("ShowTrayIcon"), NULL, dwType, (PBYTE)&g.fStartup, dwSize);
736         RegCloseKey (hk);
737     }
738
739    Shortcut_FixStartup (cszSHORTCUT_NAME, g.fStartup);
740
741    Quit();
742    EndDialog (hDlg, IDOK);
743 }
744