f50c12007274b996451bc1088a5bc65cb030cd67
[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    Config_SetTrayIconFlag (IsDlgButtonChecked (hDlg, IDC_TRAYICON));
276
277    if (g.fIsWinNT)
278       {
279       BOOL fBeGateway = IsDlgButtonChecked (hDlg, IDC_GATEWAY);
280       if (fBeGateway != g.Configuration.fBeGateway)
281          {
282          if (!Config_SetGatewayFlag (fBeGateway))
283             return FALSE;
284          g.fNeedRestart = TRUE;
285          g.Configuration.fBeGateway = fBeGateway;
286          }
287       }
288    else // (!g.fIsWinNT)
289       {
290       GetDlgItemText (hDlg, IDC_GATEWAY, szText, MAX_PATH);
291       if (lstrcmpi (szText, g.Configuration.szGateway))
292          {
293          TCHAR szNewCell[ MAX_PATH ];
294          if (!Config_ContactGateway (szText, szNewCell))
295             {
296             Message (MB_ICONASTERISK | MB_OK, GetErrorTitle(), IDS_BADGATEWAY_DESC);
297             return FALSE;
298             }
299
300          if (!GeneralTab_VerifyCell (hDlg, fComplainIfInvalid, szNewCell))
301             return FALSE;
302
303          if (!Config_SetGatewayName (szText))
304             return FALSE;
305
306          if (!Config_SetCellName (szNewCell))
307             return FALSE;
308
309          Config_FixGatewayDrives();
310
311          SetDlgItemText (hDlg, IDC_CELL, szNewCell);
312          lstrcpy (g.Configuration.szGateway, szText);
313          lstrcpy (g.Configuration.szCell, szNewCell);
314
315          GeneralTab_OnGateway (hDlg);
316          }
317       }
318
319    return TRUE;
320 }
321
322
323 void GeneralTab_OnRefresh (HWND hDlg, BOOL fRequery)
324 {
325    // If necessary, update any fields in g.Configuration that we care about
326    //
327    if (fRequery)
328       {
329       if (g.fIsWinNT)
330          Config_GetGatewayFlag (&g.Configuration.fBeGateway);
331       else
332          Config_GetGatewayName (g.Configuration.szGateway);
333
334       Config_GetCellName (g.Configuration.szCell);
335       g.Configuration.fLogonAuthent=RWLogonOption(TRUE,LOGON_OPTION_INTEGRATED);
336       Config_GetTrayIconFlag (&g.Configuration.fShowTrayIcon);
337
338       if (!g.fIsWinNT)
339          SetDlgItemText (hDlg, IDC_GATEWAY, g.Configuration.szGateway);
340       else
341          CheckDlgButton (hDlg, IDC_GATEWAY, g.Configuration.fBeGateway);
342
343       SetDlgItemText (hDlg, IDC_CELL, g.Configuration.szCell);
344       CheckDlgButton (hDlg, IDC_LOGON, g.Configuration.fLogonAuthent);
345       CheckDlgButton (hDlg, IDC_TRAYICON, g.Configuration.fShowTrayIcon);
346       }
347
348    // Update our display of the service's status
349    //
350    DWORD CurrentState = Config_GetServiceState();
351    BOOL fIfServiceStopped = !(g.fIsWinNT && !g.fIsAdmin);
352    BOOL fIfServiceRunning = fIfServiceStopped && (CurrentState == SERVICE_RUNNING);
353
354    GeneralTab_ShowCurrentState (hDlg);
355
356    EnableWindow (GetDlgItem (hDlg, IDC_CELL), fIfServiceStopped && g.fIsWinNT);
357
358    EnableWindow (GetDlgItem (hDlg, IDC_LOGON), fIfServiceStopped);
359    EnableWindow (GetDlgItem (hDlg, IDC_GATEWAY), fIfServiceStopped);
360
361    // Update our warning. Note that under WinNT, this tab doesn't have any
362    // controls (other than Start Service) which disable just because the
363    // service isn't running...so don't show that warning in that case.
364    //
365    TCHAR szText[ cchRESOURCE ];
366    if ((!g.fIsWinNT) && (CurrentState != SERVICE_RUNNING))
367       {
368       GetString (szText, IDS_WARN_STOPPED);
369       SetDlgItemText (hDlg, IDC_WARN, szText);
370       ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_SHOW);
371       }
372    else if (g.fIsWinNT && !g.fIsAdmin)
373       {
374       GetString (szText, IDS_WARN_ADMIN);
375       SetDlgItemText (hDlg, IDC_WARN, szText);
376       ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_SHOW);
377       }
378    else // ((CurrentState == SERVICE_RUNNING) && (g.fIsAdmin))
379       {
380       ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_HIDE);
381       }
382
383    GeneralTab_OnGateway (hDlg);
384
385    // If the service isn't running/stopped, we may need to complain
386    //
387    if ((CurrentState == SERVICE_RUNNING) && (l.fWarnIfNotStopped))
388       {
389       Message (MB_ICONHAND, GetErrorTitle(), IDS_SERVICE_FAIL_STOP, TEXT("%08lX"), ERROR_SERVICE_SPECIFIC_ERROR);
390       }
391    else if ((CurrentState == SERVICE_STOPPED) && (l.fWarnIfStopped))
392       {
393       Message (MB_ICONHAND, GetErrorTitle(), IDS_SERVICE_FAIL_START, TEXT("%08lX"), ERROR_SERVICE_SPECIFIC_ERROR);
394       }
395
396    if ((CurrentState == SERVICE_RUNNING) || (CurrentState == SERVICE_STOPPED))
397       {
398       BOOL fRestart = ((CurrentState == SERVICE_STOPPED) && (l.fRestartIfStopped));
399       l.fWarnIfStopped = FALSE;
400       l.fWarnIfNotStopped = FALSE;
401       l.fRestartIfStopped = FALSE;
402       l.fServiceIsRunning = (CurrentState == SERVICE_RUNNING);
403
404       if (fRestart)
405          {
406          GeneralTab_DoStartStop (hDlg, TRUE, FALSE);
407          }
408       }
409 }
410
411
412 void GeneralTab_OnTimer (HWND hDlg)
413 {
414    DWORD CurrentState = Config_GetServiceState();
415    DWORD DisplayState = GeneralTab_GetDisplayState(hDlg);
416    TestAndDoMapShare(CurrentState);             //Re map mounted drives if necessary
417
418    BOOL fInEndState = ((CurrentState == SERVICE_RUNNING) || (CurrentState == SERVICE_STOPPED));
419    if (fInEndState && l.hStatus)
420       {
421       if (IsWindow (l.hStatus))
422          DestroyWindow (l.hStatus);
423       l.hStatus = NULL;
424       }
425    else if (!fInEndState && !l.hStatus)
426       {
427       l.hStatus = ModelessDialog (IDD_STARTSTOP, GetParent (hDlg), (DLGPROC)Status_DlgProc);
428       }
429
430    if (CurrentState != DisplayState)
431       {
432       GeneralTab_OnRefresh (hDlg, FALSE);
433       Main_RefreshAllTabs();
434
435       if (l.hStatus && IsWindow (l.hStatus))
436          PostMessage (l.hStatus, WM_COMMAND, IDINIT, 0);
437       }
438
439    BOOL fNeedFastRefresh = ((CurrentState == SERVICE_STOPPED) || (CurrentState == SERVICE_RUNNING)) ? FALSE : TRUE;
440    BOOL fHaveFastRefresh = ((DisplayState == SERVICE_STOPPED) || (DisplayState == SERVICE_RUNNING)) ? FALSE : TRUE;
441
442    if (fNeedFastRefresh != fHaveFastRefresh)
443       {
444       GeneralTab_FixRefreshTimer (hDlg, ((fNeedFastRefresh) ? cmsecFAST_REFRESH : cmsecIDLE_REFRESH));
445       }
446 }
447
448
449 void GeneralTab_OnStartStop (HWND hDlg, BOOL fStart)
450 {
451    BOOL fSuccess = FALSE;
452    ULONG error = 0;
453
454    // Don't let the user stop the service on a whim; warn him first
455    //
456    if (!fStart)
457       {
458       if (Message (MB_ICONEXCLAMATION | MB_OKCANCEL, GetCautionTitle(), IDS_STOP_DESC) != IDOK)
459          return;
460       }
461
462    // To start the service, we'll need to successfully commit our new
463    // configuration. To stop the service, we'll *try*, but it's not
464    // fatal if something goes wrong.
465    //
466    if (!GeneralTab_OnApply (hDlg, TRUE, ((fStart) ? TRUE : FALSE)))
467       {
468       if (fStart)
469          return;
470       }
471
472    // Okay, start the service
473    //
474    GeneralTab_DoStartStop (hDlg, fStart, FALSE);
475 }
476
477
478 void GeneralTab_OnConnect (HWND hDlg)
479 {
480    if (!GeneralTab_OnApply (hDlg, TRUE, TRUE))
481       return;
482    GeneralTab_OnGateway (hDlg);
483    GeneralTab_OnApply (hDlg, TRUE, TRUE);
484 }
485
486
487 void GeneralTab_OnGateway (HWND hDlg)
488 {
489    if (!g.fIsWinNT)
490       {
491       TCHAR szGateway[ cchRESOURCE ];
492       GetDlgItemText (hDlg, IDC_GATEWAY, szGateway, cchRESOURCE);
493
494       BOOL fEnable = TRUE;
495       if (!szGateway[0])
496          fEnable = FALSE;
497       if (!lstrcmpi (szGateway, g.Configuration.szGateway))
498          fEnable = FALSE;
499       EnableWindow (GetDlgItem (hDlg, IDC_GATEWAY_CONN), fEnable);
500       }
501 }
502
503
504 void GeneralTab_OnCell (HWND hDlg)
505 {
506    if (g.fIsWinNT)
507       {
508       GeneralTab_ShowCurrentState (hDlg);
509       }
510 }
511
512
513 void GeneralTab_FixRefreshTimer (HWND hDlg, UINT cmsec)
514 {
515    static BOOL fTimerActive = FALSE;
516    if (fTimerActive)
517       {
518       KillTimer (hDlg, ID_TIMER);
519       fTimerActive = FALSE;
520       }
521
522    if (g.fIsWinNT && (cmsec != 0))
523       {
524       SetTimer (hDlg, ID_TIMER, cmsec, NULL);
525       }
526 }
527
528
529 DWORD GeneralTab_GetDisplayState (HWND hDlg)
530 {
531    TCHAR szText[ cchRESOURCE ];
532    TCHAR szTextNow[ cchRESOURCE ];
533    GetDlgItemText (hDlg, IDC_STATUS, szTextNow, cchRESOURCE);
534
535    GetString (szText, IDS_STATE_STOPPED);
536    if (!lstrcmpi (szTextNow, szText))
537       return SERVICE_STOPPED;
538
539    GetString (szText, IDS_STATE_RUNNING);
540    if (!lstrcmpi (szTextNow, szText))
541       return SERVICE_RUNNING;
542
543    GetString (szText, IDS_STATE_STARTING);
544    if (!lstrcmpi (szTextNow, szText))
545       return SERVICE_START_PENDING;
546
547    GetString (szText, IDS_STATE_STOPPING);
548    if (!lstrcmpi (szTextNow, szText))
549       return SERVICE_STOP_PENDING;
550
551    return 0;
552 }
553
554
555 void GeneralTab_ShowCurrentState (HWND hDlg)
556 {
557    TCHAR szNoCell[ cchRESOURCE ];
558    GetString (szNoCell, IDS_CELL_UNKNOWN);
559
560    TCHAR szCell[ cchRESOURCE ];
561    GetDlgItemText (hDlg, IDC_CELL, szCell, cchRESOURCE);
562
563    BOOL fValidCell = TRUE;
564    if (!szCell[0])
565       fValidCell = FALSE;
566    if (!lstrcmpi (szCell, szNoCell))
567       fValidCell = FALSE;
568
569    DWORD CurrentState = Config_GetServiceState();
570
571    TCHAR szText[ cchRESOURCE ];
572    switch (CurrentState)
573       {
574       case SERVICE_STOPPED:
575          GetString (szText, (fValidCell) ? IDS_STATE_STOPPED : IDS_STOPPED_NOCELL);
576          break;
577       case SERVICE_RUNNING:
578          GetString (szText, IDS_STATE_RUNNING);
579          break;
580       case SERVICE_START_PENDING:
581          GetString (szText, IDS_STATE_STARTING);
582          break;
583       case SERVICE_STOP_PENDING:
584          GetString (szText, IDS_STATE_STOPPING);
585          break;
586       default:
587          GetString (szText, IDS_STATE_UNKNOWN);
588          break;
589       }
590    SetDlgItemText (hDlg, IDC_STATUS, szText);
591
592    // Enable or disable controls as necessary
593    //
594    BOOL fIfServiceStopped = !(g.fIsWinNT && !g.fIsAdmin);
595    BOOL fIfServiceRunning = fIfServiceStopped && (CurrentState == SERVICE_RUNNING);
596
597    EnableWindow (GetDlgItem (hDlg, IDC_SERVICE_START), ((CurrentState == SERVICE_STOPPED) && (g.fIsAdmin) && (fValidCell)));
598    EnableWindow (GetDlgItem (hDlg, IDC_SERVICE_STOP),  ((CurrentState == SERVICE_RUNNING) && (g.fIsAdmin)));
599 }
600
601
602 BOOL GeneralTab_AskIfStopped (HWND hDlg)
603 {
604    BOOL fStopService = FALSE;
605    BOOL fStartService = FALSE;
606
607    // If we changed things, ask if we should restart the service.
608    // Otherwise, if it's stopped, ask the user if we should start the service.
609    //
610    DWORD CurrentState = Config_GetServiceState();
611    if (g.fIsAdmin)
612       {
613       if ((CurrentState == SERVICE_RUNNING) && (g.fNeedRestart))
614          {
615          if (Message (MB_YESNO | MB_ICONQUESTION, IDS_RESTART_TITLE, IDS_RESTART_DESC) == IDYES)
616             {
617             fStopService = TRUE;
618             fStartService = TRUE;
619             }
620          }
621       if (CurrentState == SERVICE_STOPPED)
622          {
623          if (Message (MB_YESNO | MB_ICONQUESTION, GetCautionTitle(), IDS_OKSTOP_DESC) == IDYES)
624             {
625             fStartService = TRUE;
626             }
627          }
628       }
629
630    // If we need to, start or stop-n-restart the service
631    //
632    if (fStartService && fStopService)
633       {
634       GeneralTab_DoStartStop (hDlg, FALSE, TRUE); // Stop and restart the thing
635       }
636    else if (fStartService && !fStopService)
637       {
638       GeneralTab_DoStartStop (hDlg, TRUE, FALSE); // Just start it
639       }
640
641    if (fStartService)
642       {
643       while ( (l.fRestartIfStopped) ||
644               (l.fWarnIfNotStopped) ||
645               (l.fWarnIfStopped) )
646          {
647          MSG msg;
648          if (!GetMessage (&msg, NULL, 0, 0))
649             break;
650          if (IsMemoryManagerMessage (&msg))
651             continue;
652          TranslateMessage (&msg);
653          DispatchMessage (&msg);
654          }
655       }
656
657    if (fStartService && !l.fServiceIsRunning)
658       return FALSE;
659
660    return TRUE;
661 }
662
663
664 BOOL fIsCellInCellServDB (LPCTSTR pszCell)
665 {
666    BOOL fFound = FALSE;
667    CELLSERVDB CellServDB;
668    char cellname[256], i;
669
670    /* we pray for all ascii cellnames */
671    for ( i=0 ; pszCell[i] && i < (sizeof(cellname)-1) ; i++ )
672        cellname[i] = pszCell[i];
673    cellname[i] = '\0';
674
675    ULONG code = cm_SearchCellRegistry(1, cellname, NULL, NULL, NULL, NULL);
676    if (code == 0)
677       fFound = TRUE;
678    if (!fFound && 
679        (code != CM_ERROR_FORCE_DNS_LOOKUP) && 
680        CSDB_ReadFile (&CellServDB, NULL))
681    {
682        if (CSDB_FindCell (&CellServDB, pszCell))
683            fFound = TRUE;
684        CSDB_FreeFile (&CellServDB);
685    }
686    if ( fFound == FALSE ) {
687        int ttl;
688        fFound = !cm_SearchCellByDNS(cellname, NULL, &ttl, NULL, NULL);
689    }
690    done:
691
692    return fFound;
693 }
694
695
696 void GeneralTab_DoStartStop (HWND hDlg, BOOL fStart, BOOL fRestart)
697 {
698    BOOL fSuccess = FALSE;
699    ULONG error = 0;
700
701    SC_HANDLE hManager;
702    if ((hManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS)) != NULL)
703       {
704       SC_HANDLE hService;
705       if ((hService = OpenService (hManager, TEXT("TransarcAFSDaemon"), SERVICE_ALL_ACCESS)) != NULL)
706          {
707          if (fStart)
708             {
709             g.fNeedRestart = FALSE;
710             if (StartService (hService, 0, 0))
711                                 TestAndDoMapShare(SERVICE_START_PENDING);
712                fSuccess = TRUE;
713             }
714          else // (!fStart)
715             {
716             SERVICE_STATUS Status;
717             if (ControlService (hService, SERVICE_CONTROL_STOP, &Status))
718                fSuccess = TRUE;
719                            if (g.Configuration.fLogonAuthent)
720                                    DoUnMapShare(FALSE);
721             }
722
723          CloseServiceHandle (hService);
724          }
725
726       CloseServiceHandle (hManager);
727       }
728
729    if (fSuccess)
730       {
731       l.fWarnIfStopped = fStart;
732       l.fWarnIfNotStopped = !fStart;
733       l.fRestartIfStopped = fRestart && !fStart;
734       l.fStarting = fStart;
735       GeneralTab_OnTimer (hDlg);
736       }
737    else
738       {
739       l.fWarnIfStopped = FALSE;
740       l.fWarnIfNotStopped = FALSE;
741       l.fRestartIfStopped = FALSE;
742       GeneralTab_OnTimer (hDlg);
743
744       if (!error)
745          error = GetLastError();
746       Message (MB_OK | MB_ICONHAND, GetErrorTitle(), ((fStart) ? IDS_SERVICE_FAIL_START : IDS_SERVICE_FAIL_STOP), TEXT("%08lX"), error);
747       }
748 }
749
750
751 BOOL CALLBACK Status_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
752 {
753    switch (msg)
754       {
755       case WM_INITDIALOG:
756          l.hStatus = hDlg;
757          ShowWindow (l.hStatus, SW_SHOW);
758          Status_OnRefresh (hDlg);
759          break;
760
761       case WM_DESTROY:
762          l.hStatus = NULL;
763          break;
764
765       case WM_COMMAND:
766          switch (LOWORD(wp))
767             {
768             case IDCANCEL:
769                DestroyWindow (hDlg);
770                break;
771
772             case IDINIT:
773                Status_OnRefresh (hDlg);
774                break;
775             }
776          break;
777       }
778
779    return FALSE;
780 }
781
782
783 void Status_OnRefresh (HWND hDlg)
784 {
785    DWORD CurrentState = Config_GetServiceState();
786    if (CurrentState == SERVICE_START_PENDING)
787       l.fStarting = TRUE;
788    else if (CurrentState == SERVICE_STOP_PENDING)
789       l.fStarting = FALSE;
790
791    ShowWindow (GetDlgItem (l.hStatus, IDC_STARTING), l.fStarting);
792    ShowWindow (GetDlgItem (l.hStatus, IDC_STOPPING), !l.fStarting);
793 }
794