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