BOOL GeneralTab_AskIfStopped (HWND hDlg) { BOOL fStopService = FALSE; BOOL fStartService = FALSE; // If we changed things, ask if we should restart the service. // Otherwise, if it's stopped, ask the user if we should start the service. // DWORD CurrentState = Config_GetServiceState(); if (g.fIsAdmin) { if ((CurrentState == SERVICE_RUNNING) && (g.fNeedRestart)) { if (Message (MB_YESNO | MB_ICONQUESTION, IDS_RESTART_TITLE, IDS_RESTART_DESC) == IDYES) { fStopService = TRUE; fStartService = TRUE; } } if (CurrentState == SERVICE_STOPPED) { if (Message (MB_YESNO | MB_ICONQUESTION, GetCautionTitle(), IDS_OKSTOP_DESC) == IDYES) { fStartService = TRUE; } } } // If we need to, start or stop-n-restart the service // if (fStartService && fStopService) { GeneralTab_DoStartStop (hDlg, FALSE, TRUE); // Stop and restart the thing } else if (fStartService && !fStopService) { GeneralTab_DoStartStop (hDlg, TRUE, FALSE); // Just start it } if (fStartService) { while ( (l.fRestartIfStopped) || (l.fWarnIfNotStopped) || (l.fWarnIfStopped) ) { MSG msg; if (!GetMessage (&msg, NULL, 0, 0)) break; if (IsMemoryManagerMessage (&msg)) continue; TranslateMessage (&msg); DispatchMessage (&msg); } } if (fStartService && !l.fServiceIsRunning) return FALSE; return TRUE; }
BOOL Config_SetProbeInt (ULONG csecProbe, ULONG *pStatus) { BOOL rc = TRUE; ULONG status = 0; // TODO: NEED REGISTRY SETTING if (Config_GetServiceState() == SERVICE_RUNNING) { struct chservinfo checkserv; memset (&checkserv, 0x00, sizeof(checkserv)); checkserv.magic = 0x12345678; checkserv.tinterval = csecProbe; BYTE OutData[ PIOCTL_MAXSIZE ]; memset (OutData, 0x00, sizeof(OutData)); struct ViceIoctl IOInfo; IOInfo.in_size = sizeof(checkserv); IOInfo.in = (char *)&checkserv; IOInfo.out = (char *)OutData; IOInfo.out_size = PIOCTL_MAXSIZE; if ((status = pioctl (0, VIOCCKSERV, &IOInfo, 1)) != 0) { rc = FALSE; } } if (pStatus && !rc) *pStatus = status; if (!rc) Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_PROBE, TEXT("%ld"), status); return rc; }
void GeneralTab_OnTimer (HWND hDlg) { DWORD CurrentState = Config_GetServiceState(); DWORD DisplayState = GeneralTab_GetDisplayState(hDlg); TestAndDoMapShare(CurrentState); //Re map mounted drives if necessary BOOL fInEndState = ((CurrentState == SERVICE_RUNNING) || (CurrentState == SERVICE_STOPPED)); if (fInEndState && l.hStatus) { if (IsWindow (l.hStatus)) DestroyWindow (l.hStatus); l.hStatus = NULL; } else if (!fInEndState && !l.hStatus) { l.hStatus = ModelessDialog (IDD_STARTSTOP, GetParent (hDlg), (DLGPROC)Status_DlgProc); } if (CurrentState != DisplayState) { GeneralTab_OnRefresh (hDlg, FALSE); Main_RefreshAllTabs(); if (l.hStatus && IsWindow (l.hStatus)) PostMessage (l.hStatus, WM_COMMAND, IDINIT, 0); } BOOL fNeedFastRefresh = ((CurrentState == SERVICE_STOPPED) || (CurrentState == SERVICE_RUNNING)) ? FALSE : TRUE; BOOL fHaveFastRefresh = ((DisplayState == SERVICE_STOPPED) || (DisplayState == SERVICE_RUNNING)) ? FALSE : TRUE; if (fNeedFastRefresh != fHaveFastRefresh) { GeneralTab_FixRefreshTimer (hDlg, ((fNeedFastRefresh) ? cmsecFAST_REFRESH : cmsecIDLE_REFRESH)); } }
void GeneralTab_OnInitDialog (HWND hDlg) { DWORD CurrentState = Config_GetServiceState(); BOOL fNeedFastRefresh = ((CurrentState == SERVICE_STOPPED) || (CurrentState == SERVICE_RUNNING)) ? FALSE : TRUE; GeneralTab_FixRefreshTimer (hDlg, ((fNeedFastRefresh) ? cmsecFAST_REFRESH : cmsecIDLE_REFRESH)); GeneralTab_OnTimer (hDlg); GeneralTab_OnRefresh (hDlg, TRUE); }
BOOL Config_SetSysName (LPCTSTR pszName, ULONG *pStatus) { BOOL rc = TRUE; ULONG status = 0; if (Config_GetServiceState() == SERVICE_RUNNING) { struct { ULONG cbData; TCHAR szData[ PIOCTL_MAXSIZE ]; } InData; memset (&InData, 0x00, sizeof(InData)); USHORT i=0, j=0, len=lstrlen(pszName); if ( len == 0 ) { Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_SYSNAME, TEXT("A sysname must be specified")); return(-1); } while ( pszName[i] ) { if ( !isspace(pszName[i]) ) { InData.szData[j++] = pszName[i]; } else if (InData.szData[j-1] != '\0') { InData.szData[j++] = '\0'; InData.cbData++; } i++; } InData.szData[j++] = '\0'; InData.cbData++; /* one word */ BYTE OutData[ PIOCTL_MAXSIZE ]; memset (OutData, 0x00, sizeof(OutData)); struct ViceIoctl IOInfo; IOInfo.in_size = sizeof(ULONG) + j; IOInfo.in = (char *)&InData; IOInfo.out = (char *)OutData; IOInfo.out_size = PIOCTL_MAXSIZE; if ((status = pioctl (0, VIOC_AFS_SYSNAME, &IOInfo, 1)) != 0) { rc = FALSE; } } if (rc) { Config_WriteGlobalString (TEXT("SysName"), pszName); } if (pStatus && !rc) *pStatus = status; if (!rc) Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_SYSNAME, TEXT("%ld"), status); return rc; }
void Status_OnRefresh (HWND hDlg) { DWORD CurrentState = Config_GetServiceState(); if (CurrentState == SERVICE_START_PENDING) l.fStarting = TRUE; else if (CurrentState == SERVICE_STOP_PENDING) l.fStarting = FALSE; ShowWindow (GetDlgItem (l.hStatus, IDC_STARTING), l.fStarting); ShowWindow (GetDlgItem (l.hStatus, IDC_STOPPING), !l.fStarting); }
PSERVERPREFS Config_GetServerPrefs (BOOL fVLServers) { PSERVERPREFS pPrefs = New (SERVERPREFS); memset (pPrefs, 0x00, sizeof(SERVERPREFS)); pPrefs->fVLServers = fVLServers; if (Config_GetServiceState() == SERVICE_RUNNING) { // We retrieve server prefs in batches--start that loop now. // size_t iOut = 0; for (int iOffset = 0; ; ) { cm_SPrefRequest_t InData; memset (&InData, 0x00, sizeof(InData)); InData.offset = iOffset; InData.flags = (pPrefs->fVLServers) ? CM_SPREF_VLONLY : 0; InData.num_servers = cSERVERPREFS_CHUNK; BYTE OutDataStorage[ sizeof(cm_SPrefInfo_t) + cSERVERPREFS_CHUNK * sizeof(cm_SPref_t) ]; memset (OutDataStorage, 0x00, sizeof(OutDataStorage)); cm_SPrefInfo_t *pOutData = (cm_SPrefInfo_t *)OutDataStorage; struct ViceIoctl IOInfo; IOInfo.in_size = sizeof(InData); IOInfo.in = (char *)&InData; IOInfo.out = (char *)pOutData; IOInfo.out_size = sizeof(cm_SPrefInfo_t) + cSERVERPREFS_CHUNK * sizeof(cm_SPref_t); if (pioctl (0, VIOC_GETSPREFS, &IOInfo, 1) != 0) break; if (!REALLOC (pPrefs->aPrefs, pPrefs->cPrefs, iOut + pOutData->num_servers, cREALLOC_PREFS)) break; for (size_t ii = 0; ii < pOutData->num_servers; ++ii) { pPrefs->aPrefs[ iOut ].ipServer = pOutData->servers[ ii ].host.s_addr; pPrefs->aPrefs[ iOut ].iRank = pOutData->servers[ ii ].rank; iOut ++; } if ((iOffset = pOutData->next_offset) == 0) break; } } return pPrefs; }
void GeneralTab_ShowCurrentState (HWND hDlg) { TCHAR szNoCell[ cchRESOURCE ]; GetString (szNoCell, IDS_CELL_UNKNOWN); TCHAR szCell[ cchRESOURCE ]; GetDlgItemText (hDlg, IDC_CELL, szCell, cchRESOURCE); BOOL fValidCell = TRUE; if (!szCell[0]) fValidCell = FALSE; if (!lstrcmpi (szCell, szNoCell)) fValidCell = FALSE; DWORD CurrentState = Config_GetServiceState(); TCHAR szText[ cchRESOURCE ]; switch (CurrentState) { case SERVICE_STOPPED: GetString (szText, (fValidCell) ? IDS_STATE_STOPPED : IDS_STOPPED_NOCELL); break; case SERVICE_RUNNING: GetString (szText, IDS_STATE_RUNNING); break; case SERVICE_START_PENDING: GetString (szText, IDS_STATE_STARTING); break; case SERVICE_STOP_PENDING: GetString (szText, IDS_STATE_STOPPING); break; default: GetString (szText, IDS_STATE_UNKNOWN); break; } SetDlgItemText (hDlg, IDC_STATUS, szText); // Enable or disable controls as necessary // BOOL fIfServiceStopped = !(g.fIsWinNT && !g.fIsAdmin); BOOL fIfServiceRunning = fIfServiceStopped && (CurrentState == SERVICE_RUNNING); EnableWindow (GetDlgItem (hDlg, IDC_SERVICE_START), ((CurrentState == SERVICE_STOPPED) && (g.fIsAdmin) && (fValidCell))); EnableWindow (GetDlgItem (hDlg, IDC_SERVICE_STOP), ((CurrentState == SERVICE_RUNNING) && (g.fIsAdmin))); }
BOOL Config_GetCacheInUse (ULONG *pckCacheInUse, ULONG *pStatus) { BOOL rc = TRUE; ULONG status = 0; *pckCacheInUse = 0; if (Config_GetServiceState() != SERVICE_RUNNING) { rc = FALSE; status = ERROR_SERVICE_NOT_ACTIVE; } else { BYTE OutData[ PIOCTL_MAXSIZE ]; memset (OutData, 0x00, sizeof(OutData)); struct ViceIoctl IOInfo; IOInfo.in_size = 0; IOInfo.in = (char *)0; IOInfo.out = (char *)OutData; IOInfo.out_size = PIOCTL_MAXSIZE; if ((status = pioctl (0, VIOCGETCACHEPARMS, &IOInfo, 1)) != 0) { rc = FALSE; } else { *pckCacheInUse = ((LONG*)OutData)[1]; } } if (pStatus && !rc) *pStatus = status; return rc; }
BOOL Config_SetServerPrefs (PSERVERPREFS pPrefs, ULONG *pStatus) { BOOL rc = TRUE; ULONG status = 0; if (pPrefs) { size_t cChanged = 0; size_t ii; for (ii = 0; ii < pPrefs->cPrefs; ++ii) { if (pPrefs->aPrefs[ ii ].fChanged) ++cChanged; } if (cChanged) { if (Config_GetServiceState() != SERVICE_RUNNING) { rc = FALSE; status = ERROR_SERVICE_NOT_ACTIVE; } else { size_t cbInDataStorage = sizeof(cm_SSetPref_t) + cChanged * sizeof(cm_SPref_t); PBYTE pInDataStorage; if ((pInDataStorage = (PBYTE)Allocate (cbInDataStorage)) == NULL) { rc = FALSE; status = ERROR_NOT_ENOUGH_MEMORY; } else { memset (pInDataStorage, 0x00, sizeof(cbInDataStorage)); cm_SSetPref_t *pInData = (cm_SSetPref_t*)pInDataStorage; pInData->flags = (pPrefs->fVLServers) ? CM_SPREF_VLONLY : 0; pInData->num_servers = cChanged; size_t iOut = 0; for (ii = 0; ii < pPrefs->cPrefs; ++ii) { if (pPrefs->aPrefs[ ii ].fChanged) { pInData->servers[ iOut ].host.s_addr = pPrefs->aPrefs[ ii ].ipServer; pInData->servers[ iOut ].rank = (unsigned short)pPrefs->aPrefs[ ii ].iRank; iOut++; } } BYTE OutDataStorage[ PIOCTL_MAXSIZE ]; struct ViceIoctl IOInfo; IOInfo.in_size = cbInDataStorage; IOInfo.in = (char *)pInData; IOInfo.out = (char *)OutDataStorage; IOInfo.out_size = PIOCTL_MAXSIZE; if ((status = pioctl (0, VIOC_SETSPREFS, &IOInfo, 1)) != 0) { rc = FALSE; } Free (pInDataStorage); } } } } if (pStatus && !rc) *pStatus = status; if (!rc) Message (MB_ICONHAND, GetErrorTitle(), IDS_FAILCONFIG_PREFS, TEXT("%ld"), status); return rc; }
void GeneralTab_OnRefresh (HWND hDlg, BOOL fRequery) { // If necessary, update any fields in g.Configuration that we care about // if (fRequery) { if (g.fIsWinNT) Config_GetGatewayFlag (&g.Configuration.fBeGateway); else Config_GetGatewayName (g.Configuration.szGateway); Config_GetCellName (g.Configuration.szCell); g.Configuration.fLogonAuthent=RWLogonOption(TRUE,LOGON_OPTION_INTEGRATED); Config_GetTrayIconFlag (&g.Configuration.fShowTrayIcon); if (!g.fIsWinNT) SetDlgItemText (hDlg, IDC_GATEWAY, g.Configuration.szGateway); else CheckDlgButton (hDlg, IDC_GATEWAY, g.Configuration.fBeGateway); SetDlgItemText (hDlg, IDC_CELL, g.Configuration.szCell); CheckDlgButton (hDlg, IDC_LOGON, g.Configuration.fLogonAuthent); CheckDlgButton (hDlg, IDC_TRAYICON, g.Configuration.fShowTrayIcon); } // Update our display of the service's status // DWORD CurrentState = Config_GetServiceState(); BOOL fIfServiceStopped = !(g.fIsWinNT && !g.fIsAdmin); BOOL fIfServiceRunning = fIfServiceStopped && (CurrentState == SERVICE_RUNNING); GeneralTab_ShowCurrentState (hDlg); EnableWindow (GetDlgItem (hDlg, IDC_CELL), fIfServiceStopped && g.fIsWinNT); EnableWindow (GetDlgItem (hDlg, IDC_LOGON), fIfServiceStopped); EnableWindow (GetDlgItem (hDlg, IDC_GATEWAY), fIfServiceStopped); // Update our warning. Note that under WinNT, this tab doesn't have any // controls (other than Start Service) which disable just because the // service isn't running...so don't show that warning in that case. // TCHAR szText[ cchRESOURCE ]; if ((!g.fIsWinNT) && (CurrentState != SERVICE_RUNNING)) { GetString (szText, IDS_WARN_STOPPED); SetDlgItemText (hDlg, IDC_WARN, szText); ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_SHOW); } else if (g.fIsWinNT && !g.fIsAdmin) { GetString (szText, IDS_WARN_ADMIN); SetDlgItemText (hDlg, IDC_WARN, szText); ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_SHOW); } else // ((CurrentState == SERVICE_RUNNING) && (g.fIsAdmin)) { ShowWindow (GetDlgItem (hDlg, IDC_WARN), SW_HIDE); } GeneralTab_OnGateway (hDlg); // If the service isn't running/stopped, we may need to complain // if ((CurrentState == SERVICE_RUNNING) && (l.fWarnIfNotStopped)) { Message (MB_ICONHAND, GetErrorTitle(), IDS_SERVICE_FAIL_STOP, TEXT("%08lX"), ERROR_SERVICE_SPECIFIC_ERROR); } else if ((CurrentState == SERVICE_STOPPED) && (l.fWarnIfStopped)) { Message (MB_ICONHAND, GetErrorTitle(), IDS_SERVICE_FAIL_START, TEXT("%08lX"), ERROR_SERVICE_SPECIFIC_ERROR); } if ((CurrentState == SERVICE_RUNNING) || (CurrentState == SERVICE_STOPPED)) { BOOL fRestart = ((CurrentState == SERVICE_STOPPED) && (l.fRestartIfStopped)); l.fWarnIfStopped = FALSE; l.fWarnIfNotStopped = FALSE; l.fRestartIfStopped = FALSE; l.fServiceIsRunning = (CurrentState == SERVICE_RUNNING); if (fRestart) { GeneralTab_DoStartStop (hDlg, TRUE, FALSE); } } }