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