4994c2b456b54e23626aafcb1e27792d22fdc4e8
[openafs.git] / src / WINNT / client_config / tab_general.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 #include <winsock2.h>
11 #include <ws2tcpip.h>
12
13 extern "C" {
14 #include <afsconfig.h>
15 #include <afs/param.h>
16 #include <roken.h>
17 #include <afs/stds.h>
18 #include <afs/cm.h>
19 #include <rx/rxkad.h>
20 #include <afs/cm_config.h>
21 }
22
23 #include "afs_config.h"
24 #include "tab_general.h"
25 #include "tab_hosts.h"
26 #include "tab_advanced.h"
27
28 #include "drivemap.h"
29 #include <adssts.h>
30
31 /*
32  * VARIABLES __________________________________________________________________
33  *
34  */
35
36 static struct l
37    {
38    BOOL fWarnIfStopped;
39    BOOL fWarnIfNotStopped;
40    BOOL fRestartIfStopped;
41    BOOL fServiceIsRunning;
42    BOOL fStarting;
43    HWND hStatus;
44    } l;
45
46
47 /*
48  * DEFINITIONS ________________________________________________________________
49  *
50  */
51
52 #define ID_TIMER                0
53
54 #define cmsecIDLE_REFRESH   10000
55 #define cmsecFAST_REFRESH    1000
56
57
58 /*
59  * PROTOTYPES _________________________________________________________________
60  *
61  */
62
63 void GeneralTab_OnInitDialog (HWND hDlg);
64 void GeneralTab_OnTimer (HWND hDlg);
65 BOOL GeneralTab_OnApply (HWND hDlg, BOOL fForce, BOOL fComplainIfInvalid);
66 void GeneralTab_OnRefresh (HWND hDlg, BOOL fRequery);
67 void GeneralTab_OnStartStop (HWND hDlg, BOOL fStart);
68 void GeneralTab_OnConnect (HWND hDlg);
69 void GeneralTab_OnGateway (HWND hDlg);
70 void GeneralTab_OnCell (HWND hDlg);
71
72 void GeneralTab_DoStartStop (HWND hDlg, BOOL fStart, BOOL fRestart);
73 void GeneralTab_FixRefreshTimer (HWND hDlg, UINT cmsec = 0);
74 DWORD GeneralTab_GetDisplayState (HWND hDlg);
75 void GeneralTab_ShowCurrentState (HWND hDlg);
76 BOOL GeneralTab_AskIfStopped (HWND hDlg);
77
78 BOOL fIsCellInCellServDB (LPCTSTR pszCell);
79
80 BOOL CALLBACK Status_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp);
81 void Status_OnRefresh (HWND hDlg);
82
83 /*
84  * ROUTINES ___________________________________________________________________
85  *
86  */
87
88 BOOL CALLBACK GeneralTab_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
89 {
90    switch (msg)
91       {
92       case WM_INITDIALOG:
93          Main_OnInitDialog (GetParent(hDlg));
94          GeneralTab_OnInitDialog (hDlg);
95          break;
96
97       case WM_DESTROY:
98          GeneralTab_FixRefreshTimer (hDlg, 0);
99          break;
100
101       case WM_TIMER:
102          GeneralTab_OnTimer (hDlg);
103          break;
104
105       case WM_COMMAND:
106          switch (LOWORD(wp))
107             {
108             case IDAPPLY:
109                if (!GeneralTab_OnApply (hDlg, FALSE, TRUE))
110                   SetWindowLongPtr (hDlg, DWLP_MSGRESULT, TRUE);
111                else if (g.fIsWinNT && !GeneralTab_AskIfStopped (hDlg))
112                   SetWindowLongPtr (hDlg, DWLP_MSGRESULT, TRUE);
113                break;
114
115             case IDC_REFRESH:
116                GeneralTab_OnRefresh (hDlg, FALSE);
117                break;
118
119             case IDC_SERVICE_START:
120                GeneralTab_OnStartStop (hDlg, TRUE);
121                break;
122
123             case IDC_SERVICE_STOP:
124                GeneralTab_OnStartStop (hDlg, FALSE);
125                break;
126
127             case IDC_GATEWAY_CONN:
128                GeneralTab_OnConnect (hDlg);
129                break;
130
131             case IDC_GATEWAY:
132                GeneralTab_OnGateway (hDlg);
133                break;
134
135             case IDC_CELL:
136                GeneralTab_OnCell (hDlg);
137                break;
138
139             case IDHELP:
140                GeneralTab_DlgProc (hDlg, WM_HELP, 0, 0);
141                break;
142             }
143          break;
144
145       case WM_HELP:
146          if (g.fIsWinNT)
147             WinHelp (hDlg, g.szHelpFile, HELP_CONTEXT, IDH_AFSCONFIG_GENERAL_NT);
148          else
149             WinHelp (hDlg, g.szHelpFile, HELP_CONTEXT, IDH_AFSCONFIG_GENERAL_95);
150          break;
151       }
152
153    return FALSE;
154 }
155
156
157 void GeneralTab_OnInitDialog (HWND hDlg)
158 {
159    DWORD CurrentState = Config_GetServiceState();
160    BOOL fNeedFastRefresh = ((CurrentState == SERVICE_STOPPED) || (CurrentState == SERVICE_RUNNING)) ? FALSE : TRUE;
161    GeneralTab_FixRefreshTimer (hDlg, ((fNeedFastRefresh) ? cmsecFAST_REFRESH : cmsecIDLE_REFRESH));
162    GeneralTab_OnTimer (hDlg);
163    GeneralTab_OnRefresh (hDlg, TRUE);
164 }
165
166
167 BOOL GeneralTab_VerifyCell (HWND hDlg, BOOL fComplainIfInvalid, LPCTSTR pszCell)
168 {
169    TCHAR szNoCell[ cchRESOURCE ];
170    GetString (szNoCell, IDS_CELL_UNKNOWN);
171
172    TCHAR szCell[ cchRESOURCE ];
173    if (pszCell)
174       lstrcpy (szCell, pszCell);
175    else
176       GetDlgItemText (hDlg, IDC_CELL, szCell, cchRESOURCE);
177    if ((!szCell[0]) || (!lstrcmpi (szNoCell, szCell)))
178       {
179       if (fComplainIfInvalid)
180          {
181          if (g.fIsWinNT)
182             Message (MB_ICONASTERISK | MB_OK, GetErrorTitle(), IDS_NOCELL_DESC);
183          else
184             Message (MB_ICONASTERISK | MB_OK, GetErrorTitle(), IDS_BADGATEWAY_DESC);
185          }
186       return FALSE;
187       }
188
189    if (!fIsCellInCellServDB (szCell))
190       {
191       if (fComplainIfInvalid)
192          {
193          if (g.fIsWinNT)
194             Message (MB_ICONASTERISK | MB_OK, GetErrorTitle(), IDS_BADCELL_DESC);
195          else
196             Message (MB_ICONASTERISK | MB_OK, GetErrorTitle(), IDS_BADGWCELL_DESC, TEXT("%s"), szCell);
197          }
198       return FALSE;
199       }
200
201    return TRUE;
202 }
203
204
205 BOOL GeneralTab_VerifyOK (HWND hDlg, BOOL fComplainIfInvalid)
206 {
207    // If it's Windows 95, make sure there's a valid Gateway entry
208    //
209    if (!g.fIsWinNT)
210       {
211       TCHAR szGateway[ cchRESOURCE ];
212       GetDlgItemText (hDlg, IDC_GATEWAY, szGateway, cchRESOURCE);
213       if (!szGateway[0])
214          {
215          if (fComplainIfInvalid)
216             Message (MB_ICONASTERISK | MB_OK, IDS_NOGATEWAY_TITLE, IDS_NOGATEWAY_DESC);
217          return FALSE;
218          }
219       }
220
221    // Make sure the cell is in our CellServDB.
222    //
223    if (g.fIsWinNT)
224       {
225       if (!GeneralTab_VerifyCell (hDlg, fComplainIfInvalid, NULL))
226          return FALSE;
227       }
228
229    return TRUE;
230 }
231
232 BOOL GeneralTab_OnApply (HWND hDlg, BOOL fForce, BOOL fComplainIfInvalid)
233 {
234    if (!fForce)
235       {
236       // Don't try to do anything if we've already failed the apply
237       if (GetWindowLongPtr (hDlg, DWLP_MSGRESULT))
238          return FALSE;
239       }
240
241    // If the user has changed CellServDB, configuration parameters for
242    // the driver or anything else, we want to commit those changes first.
243    // We *won't* commit server prefs changes yet, because we haven't yet
244    // checked to see if the service is running.
245    //
246    if (!HostsTab_CommitChanges (fForce))
247       return FALSE;
248
249    if (!AdvancedTab_CommitChanges (fForce))
250       return FALSE;
251
252    if (!GeneralTab_VerifyOK (hDlg, fComplainIfInvalid))
253       return FALSE;
254
255    TCHAR szText[ MAX_PATH ];
256
257    if (g.fIsWinNT)
258       {
259       GetDlgItemText (hDlg, IDC_CELL, szText, MAX_PATH);
260       if (lstrcmpi (szText, g.Configuration.szCell))
261          {
262          if (!Config_SetCellName (szText))
263             return FALSE;
264          lstrcpy (g.Configuration.szCell, szText);
265          }
266       }
267
268    BOOL fLogonAuthent = IsDlgButtonChecked (hDlg, IDC_LOGON);
269    if (fLogonAuthent != g.Configuration.fLogonAuthent)
270       {
271       SetBitLogonOption(fLogonAuthent,LOGON_OPTION_INTEGRATED);
272       g.Configuration.fLogonAuthent = fLogonAuthent;
273       }
274
275   if (GetDlgItem(hDlg, IDC_TRAYICON) != NULL)
276       Config_SetTrayIconFlag (IsDlgButtonChecked(hDlg, IDC_TRAYICON));
277
278    if (g.fIsWinNT)
279       {
280       BOOL fBeGateway = IsDlgButtonChecked (hDlg, IDC_GATEWAY);
281       if (fBeGateway != g.Configuration.fBeGateway)
282          {
283          if (!Config_SetGatewayFlag (fBeGateway))
284             return FALSE;
285          g.fNeedRestart = TRUE;
286          g.Configuration.fBeGateway = fBeGateway;
287          }
288       }
289    else // (!g.fIsWinNT)
290       {
291       GetDlgItemText (hDlg, IDC_GATEWAY, szText, MAX_PATH);
292       if (lstrcmpi (szText, g.Configuration.szGateway))
293          {
294          TCHAR szNewCell[ MAX_PATH ];
295          if (!Config_ContactGateway (szText, szNewCell))
296             {
297             Message (MB_ICONASTERISK | MB_OK, GetErrorTitle(), IDS_BADGATEWAY_DESC);
298             return FALSE;
299             }
300
301          if (!GeneralTab_VerifyCell (hDlg, fComplainIfInvalid, szNewCell))
302             return FALSE;
303
304          if (!Config_SetGatewayName (szText))
305             return FALSE;
306
307          if (!Config_SetCellName (szNewCell))
308             return FALSE;
309
310          Config_FixGatewayDrives();
311
312          SetDlgItemText (hDlg, IDC_CELL, szNewCell);
313          lstrcpy (g.Configuration.szGateway, szText);
314          lstrcpy (g.Configuration.szCell, szNewCell);
315
316          GeneralTab_OnGateway (hDlg);
317          }
318       }
319
320    return TRUE;
321 }
322
323
324 void GeneralTab_OnRefresh (HWND hDlg, BOOL fRequery)
325 {
326    // If necessary, update any fields in g.Configuration that we care about
327    //
328    if (fRequery)
329       {
330       if (g.fIsWinNT)
331          Config_GetGatewayFlag (&g.Configuration.fBeGateway);
332       else
333          Config_GetGatewayName (g.Configuration.szGateway);
334
335       Config_GetCellName (g.Configuration.szCell);
336       g.Configuration.fLogonAuthent=RWLogonOption(TRUE,LOGON_OPTION_INTEGRATED);
337       Config_GetTrayIconFlag (&g.Configuration.fShowTrayIcon);
338
339       if (!g.fIsWinNT)
340          SetDlgItemText (hDlg, IDC_GATEWAY, g.Configuration.szGateway);
341       else
342          CheckDlgButton (hDlg, IDC_GATEWAY, g.Configuration.fBeGateway);
343
344       SetDlgItemText (hDlg, IDC_CELL, g.Configuration.szCell);
345       CheckDlgButton (hDlg, IDC_LOGON, g.Configuration.fLogonAuthent);
346       CheckDlgButton (hDlg, IDC_TRAYICON, g.Configuration.fShowTrayIcon);
347       }
348
349    // Update our display of the service's status
350    //
351    DWORD CurrentState = Config_GetServiceState();
352    BOOL fIfServiceStopped = !(g.fIsWinNT && !g.fIsAdmin);
353    BOOL fIfServiceRunning = fIfServiceStopped && (CurrentState == SERVICE_RUNNING);
354
355    GeneralTab_ShowCurrentState (hDlg);
356
357    EnableWindow (GetDlgItem (hDlg, IDC_CELL), fIfServiceStopped && g.fIsWinNT);
358
359    EnableWindow (GetDlgItem (hDlg, IDC_LOGON), fIfServiceStopped);
360    EnableWindow (GetDlgItem (hDlg, IDC_GATEWAY), fIfServiceStopped);
361
362    // Update our warning. Note that under WinNT, this tab doesn't have any
363    // controls (other than Start Service) which disable just because the
364    // service isn't running...so don't show that warning in that case.
365    //
366    TCHAR szText[ cchRESOURCE ];
367    if ((!g.fIsWinNT) && (CurrentState != SERVICE_RUNNING))
368       {
369       GetString (szText, IDS_WARN_STOPPED);
370       SetDlgItemText (hDlg, IDC_WARN, szText);
371       ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_SHOW);
372       }
373    else if (g.fIsWinNT && !g.fIsAdmin)
374       {
375       GetString (szText, IDS_WARN_ADMIN);
376       SetDlgItemText (hDlg, IDC_WARN, szText);
377       ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_SHOW);
378       }
379    else // ((CurrentState == SERVICE_RUNNING) && (g.fIsAdmin))
380       {
381       ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_HIDE);
382       }
383
384    GeneralTab_OnGateway (hDlg);
385
386    // If the service isn't running/stopped, we may need to complain
387    //
388    if ((CurrentState == SERVICE_RUNNING) && (l.fWarnIfNotStopped))
389       {
390       Message (MB_ICONHAND, GetErrorTitle(), IDS_SERVICE_FAIL_STOP, TEXT("%08lX"), ERROR_SERVICE_SPECIFIC_ERROR);
391       }
392    else if ((CurrentState == SERVICE_STOPPED) && (l.fWarnIfStopped))
393       {
394       Message (MB_ICONHAND, GetErrorTitle(), IDS_SERVICE_FAIL_START, TEXT("%08lX"), ERROR_SERVICE_SPECIFIC_ERROR);
395       }
396
397    if ((CurrentState == SERVICE_RUNNING) || (CurrentState == SERVICE_STOPPED))
398       {
399       BOOL fRestart = ((CurrentState == SERVICE_STOPPED) && (l.fRestartIfStopped));
400       l.fWarnIfStopped = FALSE;
401       l.fWarnIfNotStopped = FALSE;
402       l.fRestartIfStopped = FALSE;
403       l.fServiceIsRunning = (CurrentState == SERVICE_RUNNING);
404
405       if (fRestart)
406          {
407          GeneralTab_DoStartStop (hDlg, TRUE, FALSE);
408          }
409       }
410 }
411
412
413 void GeneralTab_OnTimer (HWND hDlg)
414 {
415    DWORD CurrentState = Config_GetServiceState();
416    DWORD DisplayState = GeneralTab_GetDisplayState(hDlg);
417    TestAndDoMapShare(CurrentState);             //Re map mounted drives if necessary
418
419    BOOL fInEndState = ((CurrentState == SERVICE_RUNNING) || (CurrentState == SERVICE_STOPPED));
420    if (fInEndState && l.hStatus)
421       {
422       if (IsWindow (l.hStatus))
423          DestroyWindow (l.hStatus);
424       l.hStatus = NULL;
425       }
426    else if (!fInEndState && !l.hStatus)
427       {
428       l.hStatus = ModelessDialog (IDD_STARTSTOP, GetParent (hDlg), (DLGPROC)Status_DlgProc);
429       }
430
431    if (CurrentState != DisplayState)
432       {
433       GeneralTab_OnRefresh (hDlg, FALSE);
434       Main_RefreshAllTabs();
435
436       if (l.hStatus && IsWindow (l.hStatus))
437          PostMessage (l.hStatus, WM_COMMAND, IDINIT, 0);
438       }
439
440    BOOL fNeedFastRefresh = ((CurrentState == SERVICE_STOPPED) || (CurrentState == SERVICE_RUNNING)) ? FALSE : TRUE;
441    BOOL fHaveFastRefresh = ((DisplayState == SERVICE_STOPPED) || (DisplayState == SERVICE_RUNNING)) ? FALSE : TRUE;
442
443    if (fNeedFastRefresh != fHaveFastRefresh)
444       {
445       GeneralTab_FixRefreshTimer (hDlg, ((fNeedFastRefresh) ? cmsecFAST_REFRESH : cmsecIDLE_REFRESH));
446       }
447 }
448
449
450 void GeneralTab_OnStartStop (HWND hDlg, BOOL fStart)
451 {
452    BOOL fSuccess = FALSE;
453    ULONG error = 0;
454
455    // Don't let the user stop the service on a whim; warn him first
456    //
457    if (!fStart)
458       {
459       if (Message (MB_ICONEXCLAMATION | MB_OKCANCEL, GetCautionTitle(), IDS_STOP_DESC) != IDOK)
460          return;
461       }
462
463    // To start the service, we'll need to successfully commit our new
464    // configuration. To stop the service, we'll *try*, but it's not
465    // fatal if something goes wrong.
466    //
467    if (!GeneralTab_OnApply (hDlg, TRUE, ((fStart) ? TRUE : FALSE)))
468       {
469       if (fStart)
470          return;
471       }
472
473    // Okay, start the service
474    //
475    GeneralTab_DoStartStop (hDlg, fStart, FALSE);
476 }
477
478
479 void GeneralTab_OnConnect (HWND hDlg)
480 {
481    if (!GeneralTab_OnApply (hDlg, TRUE, TRUE))
482       return;
483    GeneralTab_OnGateway (hDlg);
484    GeneralTab_OnApply (hDlg, TRUE, TRUE);
485 }
486
487
488 void GeneralTab_OnGateway (HWND hDlg)
489 {
490    if (!g.fIsWinNT)
491       {
492       TCHAR szGateway[ cchRESOURCE ];
493       GetDlgItemText (hDlg, IDC_GATEWAY, szGateway, cchRESOURCE);
494
495       BOOL fEnable = TRUE;
496       if (!szGateway[0])
497          fEnable = FALSE;
498       if (!lstrcmpi (szGateway, g.Configuration.szGateway))
499          fEnable = FALSE;
500       EnableWindow (GetDlgItem (hDlg, IDC_GATEWAY_CONN), fEnable);
501       }
502 }
503
504
505 void GeneralTab_OnCell (HWND hDlg)
506 {
507    if (g.fIsWinNT)
508       {
509       GeneralTab_ShowCurrentState (hDlg);
510       }
511 }
512
513
514 void GeneralTab_FixRefreshTimer (HWND hDlg, UINT cmsec)
515 {
516    static BOOL fTimerActive = FALSE;
517    if (fTimerActive)
518       {
519       KillTimer (hDlg, ID_TIMER);
520       fTimerActive = FALSE;
521       }
522
523    if (g.fIsWinNT && (cmsec != 0))
524       {
525       SetTimer (hDlg, ID_TIMER, cmsec, NULL);
526       }
527 }
528
529
530 DWORD GeneralTab_GetDisplayState (HWND hDlg)
531 {
532    TCHAR szText[ cchRESOURCE ];
533    TCHAR szTextNow[ cchRESOURCE ];
534    GetDlgItemText (hDlg, IDC_STATUS, szTextNow, cchRESOURCE);
535
536    GetString (szText, IDS_STATE_STOPPED);
537    if (!lstrcmpi (szTextNow, szText))
538       return SERVICE_STOPPED;
539
540    GetString (szText, IDS_STATE_RUNNING);
541    if (!lstrcmpi (szTextNow, szText))
542       return SERVICE_RUNNING;
543
544    GetString (szText, IDS_STATE_STARTING);
545    if (!lstrcmpi (szTextNow, szText))
546       return SERVICE_START_PENDING;
547
548    GetString (szText, IDS_STATE_STOPPING);
549    if (!lstrcmpi (szTextNow, szText))
550       return SERVICE_STOP_PENDING;
551
552    return 0;
553 }
554
555
556 void GeneralTab_ShowCurrentState (HWND hDlg)
557 {
558    TCHAR szNoCell[ cchRESOURCE ];
559    GetString (szNoCell, IDS_CELL_UNKNOWN);
560
561    TCHAR szCell[ cchRESOURCE ];
562    GetDlgItemText (hDlg, IDC_CELL, szCell, cchRESOURCE);
563
564    BOOL fValidCell = TRUE;
565    if (!szCell[0])
566       fValidCell = FALSE;
567    if (!lstrcmpi (szCell, szNoCell))
568       fValidCell = FALSE;
569
570    DWORD CurrentState = Config_GetServiceState();
571
572    TCHAR szText[ cchRESOURCE ];
573    switch (CurrentState)
574       {
575       case SERVICE_STOPPED:
576          GetString (szText, (fValidCell) ? IDS_STATE_STOPPED : IDS_STOPPED_NOCELL);
577          break;
578       case SERVICE_RUNNING:
579          GetString (szText, IDS_STATE_RUNNING);
580          break;
581       case SERVICE_START_PENDING:
582          GetString (szText, IDS_STATE_STARTING);
583          break;
584       case SERVICE_STOP_PENDING:
585          GetString (szText, IDS_STATE_STOPPING);
586          break;
587       default:
588          GetString (szText, IDS_STATE_UNKNOWN);
589          break;
590       }
591    SetDlgItemText (hDlg, IDC_STATUS, szText);
592
593    // Enable or disable controls as necessary
594    //
595    BOOL fIfServiceStopped = !(g.fIsWinNT && !g.fIsAdmin);
596    BOOL fIfServiceRunning = fIfServiceStopped && (CurrentState == SERVICE_RUNNING);
597
598    EnableWindow (GetDlgItem (hDlg, IDC_SERVICE_START), ((CurrentState == SERVICE_STOPPED) && (g.fIsAdmin) && (fValidCell)));
599    EnableWindow (GetDlgItem (hDlg, IDC_SERVICE_STOP),  ((CurrentState == SERVICE_RUNNING) && (g.fIsAdmin)));
600 }
601
602
603 BOOL GeneralTab_AskIfStopped (HWND hDlg)
604 {
605    BOOL fStopService = FALSE;
606    BOOL fStartService = FALSE;
607
608    // If we changed things, ask if we should restart the service.
609    // Otherwise, if it's stopped, ask the user if we should start the service.
610    //
611    DWORD CurrentState = Config_GetServiceState();
612    if (g.fIsAdmin)
613       {
614       if ((CurrentState == SERVICE_RUNNING) && (g.fNeedRestart))
615          {
616          if (Message (MB_YESNO | MB_ICONQUESTION, IDS_RESTART_TITLE, IDS_RESTART_DESC) == IDYES)
617             {
618             fStopService = TRUE;
619             fStartService = TRUE;
620             }
621          }
622       if (CurrentState == SERVICE_STOPPED)
623          {
624          if (Message (MB_YESNO | MB_ICONQUESTION, GetCautionTitle(), IDS_OKSTOP_DESC) == IDYES)
625             {
626             fStartService = TRUE;
627             }
628          }
629       }
630
631    // If we need to, start or stop-n-restart the service
632    //
633    if (fStartService && fStopService)
634       {
635       GeneralTab_DoStartStop (hDlg, FALSE, TRUE); // Stop and restart the thing
636       }
637    else if (fStartService && !fStopService)
638       {
639       GeneralTab_DoStartStop (hDlg, TRUE, FALSE); // Just start it
640       }
641
642    if (fStartService)
643       {
644       while ( (l.fRestartIfStopped) ||
645               (l.fWarnIfNotStopped) ||
646               (l.fWarnIfStopped) )
647          {
648          MSG msg;
649          if (!GetMessage (&msg, NULL, 0, 0))
650             break;
651          if (IsMemoryManagerMessage (&msg))
652             continue;
653          TranslateMessage (&msg);
654          DispatchMessage (&msg);
655          }
656       }
657
658    if (fStartService && !l.fServiceIsRunning)
659       return FALSE;
660
661    return TRUE;
662 }
663
664
665 BOOL fIsCellInCellServDB (LPCTSTR pszCell)
666 {
667    BOOL fFound = FALSE;
668    CELLSERVDB CellServDB;
669    char cellname[256], i;
670
671    /* we pray for all ascii cellnames */
672    for ( i=0 ; pszCell[i] && i < (sizeof(cellname)-1) ; i++ )
673        cellname[i] = pszCell[i];
674    cellname[i] = '\0';
675
676    ULONG code = cm_SearchCellRegistry(1, cellname, NULL, NULL, NULL, NULL);
677    if (code == 0)
678       fFound = TRUE;
679    if (!fFound && 
680        (code != CM_ERROR_FORCE_DNS_LOOKUP) && 
681        CSDB_ReadFile (&CellServDB, NULL))
682    {
683        if (CSDB_FindCell (&CellServDB, pszCell))
684            fFound = TRUE;
685        CSDB_FreeFile (&CellServDB);
686    }
687    if ( fFound == FALSE ) {
688        int ttl;
689        fFound = !cm_SearchCellByDNS(cellname, NULL, &ttl, NULL, NULL);
690    }
691    done:
692
693    return fFound;
694 }
695
696
697 void GeneralTab_DoStartStop (HWND hDlg, BOOL fStart, BOOL fRestart)
698 {
699    BOOL fSuccess = FALSE;
700    ULONG error = 0;
701
702    SC_HANDLE hManager;
703    if ((hManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS)) != NULL)
704       {
705       SC_HANDLE hService;
706       if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), SERVICE_ALL_ACCESS)) != NULL)
707          {
708          if (fStart)
709             {
710             g.fNeedRestart = FALSE;
711             if (StartService (hService, 0, 0))
712                                 TestAndDoMapShare(SERVICE_START_PENDING);
713                fSuccess = TRUE;
714             }
715          else // (!fStart)
716             {
717             SERVICE_STATUS Status;
718             if (ControlService (hService, SERVICE_CONTROL_STOP, &Status))
719                fSuccess = TRUE;
720                            if (g.Configuration.fLogonAuthent)
721                                    DoUnMapShare(FALSE);
722             }
723
724          CloseServiceHandle (hService);
725          }
726
727       CloseServiceHandle (hManager);
728       }
729
730    if (fSuccess)
731       {
732       l.fWarnIfStopped = fStart;
733       l.fWarnIfNotStopped = !fStart;
734       l.fRestartIfStopped = fRestart && !fStart;
735       l.fStarting = fStart;
736       GeneralTab_OnTimer (hDlg);
737       }
738    else
739       {
740       l.fWarnIfStopped = FALSE;
741       l.fWarnIfNotStopped = FALSE;
742       l.fRestartIfStopped = FALSE;
743       GeneralTab_OnTimer (hDlg);
744
745       if (!error)
746          error = GetLastError();
747       Message (MB_OK | MB_ICONHAND, GetErrorTitle(), ((fStart) ? IDS_SERVICE_FAIL_START : IDS_SERVICE_FAIL_STOP), TEXT("%08lX"), error);
748       }
749 }
750
751
752 BOOL CALLBACK Status_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
753 {
754    switch (msg)
755       {
756       case WM_INITDIALOG:
757          l.hStatus = hDlg;
758          ShowWindow (l.hStatus, SW_SHOW);
759          Status_OnRefresh (hDlg);
760          break;
761
762       case WM_DESTROY:
763          l.hStatus = NULL;
764          break;
765
766       case WM_COMMAND:
767          switch (LOWORD(wp))
768             {
769             case IDCANCEL:
770                DestroyWindow (hDlg);
771                break;
772
773             case IDINIT:
774                Status_OnRefresh (hDlg);
775                break;
776             }
777          break;
778       }
779
780    return FALSE;
781 }
782
783
784 void Status_OnRefresh (HWND hDlg)
785 {
786    DWORD CurrentState = Config_GetServiceState();
787    if (CurrentState == SERVICE_START_PENDING)
788       l.fStarting = TRUE;
789    else if (CurrentState == SERVICE_STOP_PENDING)
790       l.fStarting = FALSE;
791
792    ShowWindow (GetDlgItem (l.hStatus, IDC_STARTING), l.fStarting);
793    ShowWindow (GetDlgItem (l.hStatus, IDC_STOPPING), !l.fStarting);
794 }
795