able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/mmc/mprsnap/radcfg.cpp

1690 lines
44 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1998 - 1999 **/
/**********************************************************************/
/*
radcfg.cpp
Implementation file for the RADIUS config object.
FILE HISTORY:
*/
#include "stdafx.h"
#include "root.h"
#include "lsa.h"
#include "radcfg.h"
#include "rtrstr.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
// This is used as the seed value for the RtlRunEncodeUnicodeString
// and RtlRunDecodeUnicodeString functions.
#define ENCRYPT_SEED (0xA5)
//max # of digits of the score of a radius server
#define SCORE_MAX_DIGITS 8
//max # of chars in a radius server name
#define MAX_RADIUS_NAME 256
// Const string used when displaying the old secret. It's a fixed length.
const TCHAR c_szDisplayedSecret[] = _T("\b\b\b\b\b\b\b\b");
const int c_nListColumns = 2;
/*!--------------------------------------------------------------------------
RouterAuthRadiusConfig::Initialize
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAuthRadiusConfig::Initialize(LPCOLESTR pszMachineName,
ULONG_PTR *puConnection)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
// for now, allocate a string and have it point at the string
// ------------------------------------------------------------
*puConnection = (ULONG_PTR) StrDupTFromOle(pszMachineName);
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterAuthRadiusConfig::Uninitialize
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAuthRadiusConfig::Uninitialize(ULONG_PTR uConnection)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
delete (TCHAR *) uConnection;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterAuthRadiusConfig::Configure
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAuthRadiusConfig::Configure(
ULONG_PTR uConnection,
HWND hWnd,
DWORD dwFlags,
ULONG_PTR uReserved1,
ULONG_PTR uReserved2)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
RadiusServerDialog authDlg(TRUE, IDS_RADIUS_SERVER_AUTH_TITLE);
// parameter checking
// ----------------------------------------------------------------
if (uConnection == 0)
return E_INVALIDARG;
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
authDlg.SetServer((LPCTSTR) uConnection);
authDlg.DoModal();
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterAuthRadiusConfig::Activate
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAuthRadiusConfig::Activate(
ULONG_PTR uConnection,
ULONG_PTR uReserved1,
ULONG_PTR uReserved2)
{
// parameter checking
// ----------------------------------------------------------------
if (uConnection == 0)
return E_INVALIDARG;
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterAuthRadiusConfig::Deactivate
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAuthRadiusConfig::Deactivate(
ULONG_PTR uConnection,
ULONG_PTR uReserved1,
ULONG_PTR uReserved2)
{
// parameter checking
// ----------------------------------------------------------------
if (uConnection == 0)
return E_INVALIDARG;
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
}
COM_PROTECT_CATCH;
return hr;
}
/*---------------------------------------------------------------------------
RadiusServerDialog implementation
---------------------------------------------------------------------------*/
RadiusServerDialog::RadiusServerDialog(BOOL fAuth, UINT idsTitle)
: CBaseDialog(RadiusServerDialog::IDD),
m_hkeyMachine(NULL),
m_idsTitle(idsTitle),
m_fAuthDialog(fAuth)
{
}
RadiusServerDialog::~RadiusServerDialog()
{
if (m_hkeyMachine)
{
DisconnectRegistry(m_hkeyMachine);
m_hkeyMachine = NULL;
}
}
BEGIN_MESSAGE_MAP(RadiusServerDialog, CBaseDialog)
//{{AFX_MSG_MAP(RadiusServerDialog)
ON_BN_CLICKED(IDC_RADAUTH_BTN_ADD, OnBtnAdd)
ON_BN_CLICKED(IDC_RADAUTH_BTN_EDIT, OnBtnEdit)
ON_BN_CLICKED(IDC_RADAUTH_BTN_DELETE, OnBtnDelete)
ON_NOTIFY(NM_DBLCLK, IDC_RADAUTH_LIST, OnListDblClk)
ON_NOTIFY(LVN_ITEMCHANGED, IDC_RADAUTH_LIST, OnNotifyListItemChanged)
ON_WM_VSCROLL()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/*!--------------------------------------------------------------------------
RadiusScoreCompareProc
- The comparison function for sort of radius server list
Author: NSun
---------------------------------------------------------------------------*/
int CALLBACK RadiusScoreCompareProc(LPARAM lParam1, LPARAM lParam2, LPARAM lSort)
{
RADIUSSERVER *pServer1 = NULL;
RADIUSSERVER *pServer2 = NULL;
RADIUSSERVER *pServer = NULL;
CRadiusServers *pServerList = (CRadiusServers*)lSort;
for (pServer = pServerList->GetNextServer(TRUE); pServer;
pServer = pServerList->GetNextServer(FALSE) )
{
if (pServer->dwUnique == (DWORD) lParam1)
{
//Server 1 found
pServer1 = pServer;
//if server 2 also found, end search
if (pServer2)
break;
}
else if (pServer->dwUnique == (DWORD) lParam2)
{
//server 2 found
pServer2 = pServer;
//if server 1 also found, end search
if (pServer1)
break;
}
}
if (!pServer1 || !pServer2)
{
Panic0("We can't find the server in the list (but we should)!");
return 0;
}
else
return pServer2->cScore - pServer1->cScore;
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::DoDataExchange
-
Author: KennT
---------------------------------------------------------------------------*/
void RadiusServerDialog::DoDataExchange(CDataExchange* pDX)
{
CBaseDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(RadiusServerDialog)
DDX_Control(pDX, IDC_RADAUTH_LIST, m_ListServers);
//}}AFX_DATA_MAP
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::SetServer
Sets the name of the machine we are looking at.
Author: KennT
---------------------------------------------------------------------------*/
void RadiusServerDialog::SetServer(LPCTSTR pszServerName)
{
m_stServerName = pszServerName;
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::OnInitDialog
-
Author: KennT
---------------------------------------------------------------------------*/
BOOL RadiusServerDialog::OnInitDialog()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
RADIUSSERVER * pServer;
int iPos;
CString stTitle;
LV_COLUMN lvCol; // list view column struct for radius servers
RECT rect;
CBaseDialog::OnInitDialog();
ListView_SetExtendedListViewStyle(m_ListServers.GetSafeHwnd(),
LVS_EX_FULLROWSELECT);
Assert(m_hkeyMachine == 0);
stTitle.LoadString(m_idsTitle);
SetWindowText(stTitle);
// Connect to the machine (get the registry key)
if (ConnectRegistry(m_stServerName, &m_hkeyMachine) != ERROR_SUCCESS)
{
//$ TODO : put in error messages here
// we failed to connect, error out
OnCancel();
return TRUE;
}
// Get the list of RADIUS servers
LoadRadiusServers(m_stServerName,
m_hkeyMachine,
m_fAuthDialog,
&m_ServerList,
0);
// Get the other list of RADIUS servers
LoadRadiusServers(m_stServerName,
m_hkeyMachine,
!m_fAuthDialog,
&m_OtherServerList,
RADIUS_FLAG_NOUI | RADIUS_FLAG_NOIP);
m_ListServers.GetClientRect(&rect);
int nColWidth = rect.right / c_nListColumns;
lvCol.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT;
lvCol.fmt = LVCFMT_LEFT;
lvCol.cx = nColWidth;
CString stColCaption;
for(int index = 0; index < c_nListColumns; index++)
{
stColCaption.LoadString((0 == index) ? IDS_RADIUS_CONFIG_RADIUS: IDS_RADIUS_CONFIG_SCORE);
lvCol.pszText = (LPTSTR)((LPCTSTR) stColCaption);
m_ListServers.InsertColumn(index, &lvCol);
}
// Now iterate through the server list and add the servers to the
// list box
LV_ITEM lvItem;
lvItem.mask = LVIF_TEXT | LVIF_PARAM;
lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
lvItem.state = 0;
int nCount = 0;
TCHAR szBufScore[SCORE_MAX_DIGITS];
for (pServer = m_ServerList.GetNextServer(TRUE); pServer;
pServer = m_ServerList.GetNextServer(FALSE) )
{
lvItem.iItem = nCount;
lvItem.iSubItem = 0;
lvItem.pszText = pServer->szName;
lvItem.lParam = pServer->dwUnique; //same functionality as SetItemData()
iPos = m_ListServers.InsertItem(&lvItem);
if (iPos != -1)
{
_itot(pServer->cScore, szBufScore, 10);
m_ListServers.SetItemText(iPos, 1, szBufScore);
nCount++;
}
}
if (m_ListServers.GetItemCount())
{
m_ListServers.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
m_ListServers.SortItems(RadiusScoreCompareProc, (LPARAM)&m_ServerList);
}
else
{
GetDlgItem(IDC_RADAUTH_BTN_DELETE)->EnableWindow(FALSE);
GetDlgItem(IDC_RADAUTH_BTN_EDIT)->EnableWindow(FALSE);
}
return TRUE;
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::OnOK
-
Author: KennT
---------------------------------------------------------------------------*/
void RadiusServerDialog::OnOK()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
RADIUSSERVER * pServer;
HRESULT hr = hrOK;
// fix 8155 rajeshp 06/15/1998 RADIUS: Updating of the radius server entries in the snapin requires a restart of remoteaccess.
DWORD dwMajor = 0, dwMinor = 0, dwBuildNo = 0;
GetNTVersion(m_hkeyMachine, &dwMajor, &dwMinor, &dwBuildNo);
DWORD dwVersionCombine = MAKELONG( dwBuildNo, MAKEWORD(dwMinor, dwMajor));
DWORD dwVersionCombineNT50 = MAKELONG ( VER_BUILD_WIN2K, MAKEWORD(VER_MINOR_WIN2K, VER_MAJOR_WIN2K));
// if the version is greater than Win2K release
if(dwVersionCombine > dwVersionCombineNT50)
; // skip the restart message
else
AfxMessageBox(IDS_WRN_RADIUS_PARAMS_CHANGING);
// Clear out the deleted server list
// Do this before we save the list (otherwise the list
// may have an LSA entry that we will delete).
// ----------------------------------------------------------------
m_ServerList.ClearDeletedServerList(m_stServerName);
pServer = m_ServerList.GetNextServer(TRUE);
hr = SaveRadiusServers(m_stServerName,
m_hkeyMachine,
m_fAuthDialog,
pServer);
if (!FHrSucceeded(hr))
{
DisplayErrorMessage(GetSafeHwnd(), hr);
return;
}
CBaseDialog::OnOK();
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::OnBtnAdd
-
Author: KennT
---------------------------------------------------------------------------*/
void RadiusServerDialog::OnBtnAdd()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
ServerPropDialog * pServerDlg;
RADIUSSERVER server;
int iPos;
ServerPropDialog authDlg(FALSE);
ServerPropAcctDialog acctDlg(FALSE);
if (m_fAuthDialog)
pServerDlg = &authDlg;
else
pServerDlg = &acctDlg;
if (pServerDlg->DoModal() == IDOK)
{
ZeroMemory(&server, sizeof(server));
pServerDlg->GetDefault(&server);
CString stText;
BOOL bFound = FALSE;
int nCount = m_ListServers.GetItemCount();
if(nCount > 0)
{
TCHAR szRadSrvName[MAX_RADIUS_NAME];
//we need case insensitive comparation, so cannot use CListBox::FindStringExact()
for(int iIndex = 0; iIndex < nCount; iIndex++)
{
m_ListServers.GetItemText(iIndex, 0, szRadSrvName, MAX_RADIUS_NAME);
if(lstrcmpi(szRadSrvName, server.szName) == 0)
{
bFound = TRUE;
break;
}
}
}
//if the server is already is the list, we won't add it.
if(bFound)
{
CString stText;
stText.Format(IDS_ERR_RADIUS_DUP_NAME, server.szName);
AfxMessageBox((LPCTSTR)stText, MB_OK | MB_ICONEXCLAMATION);
}
else
{
// Add to the server list
m_ServerList.AddServer(&server, 0);
// Add to the list control
TCHAR szBuf[SCORE_MAX_DIGITS];
LV_ITEM lvItem;
lvItem.mask = LVIF_TEXT | LVIF_PARAM;
lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
lvItem.state = 0;
lvItem.iItem = 0;
lvItem.iSubItem = 0;
lvItem.pszText = server.szName;
lvItem.lParam = server.dwUnique; //same functionality as SetItemData()
iPos = m_ListServers.InsertItem(&lvItem);
_itot(server.cScore, szBuf, 10);
m_ListServers.SetItemText(iPos, 1, szBuf);
if (iPos != -1)
{
//if no radius server in the list previously, select the new added server.
// (and enable "edit" and "delete" buttons in OnNotifyListItemChanged()
if (nCount == 0)
m_ListServers.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
m_ListServers.SortItems(RadiusScoreCompareProc, (LPARAM)&m_ServerList);
}
}
}
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::OnBtnDelete
-
Author: KennT
---------------------------------------------------------------------------*/
void RadiusServerDialog::OnBtnDelete()
{
// Get the selection and delete it
int iPos;
ULONG_PTR dwUnique;
RADIUSSERVER * pServer = NULL;
BOOL fRemoveLSAEntry = FALSE;
iPos = m_ListServers.GetNextItem(-1, LVNI_SELECTED);
if (iPos == -1)
return;
dwUnique = m_ListServers.GetItemData(iPos);
// Does this server exist in the other list
Verify( m_ServerList.FindServer((DWORD) dwUnique, &pServer) );
Assert(pServer);
// If we find this server in the other list, we can't remove its
// LSA entry
fRemoveLSAEntry = !m_OtherServerList.FindServer(pServer->szName, NULL);
m_ServerList.DeleteServer(dwUnique, fRemoveLSAEntry);
m_ListServers.DeleteItem(iPos);
// See if we can move the selection to the next item in the list
// if that fails, try to set it to the previous item
if (!m_ListServers.SetItemState(iPos, LVIS_SELECTED, LVIS_SELECTED))
m_ListServers.SetItemState(iPos - 1, LVIS_SELECTED, LVIS_SELECTED);
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::OnBtnEdit
-
Author: KennT
---------------------------------------------------------------------------*/
void RadiusServerDialog::OnBtnEdit()
{
ServerPropDialog * pServerDlg;
RADIUSSERVER server;
RADIUSSERVER * pServer;
int iOldPos, iPos;
LONG_PTR dwUnique;
ServerPropDialog authDlg(TRUE);
ServerPropAcctDialog acctDlg(TRUE);
if (m_fAuthDialog)
pServerDlg = &authDlg;
else
pServerDlg = &acctDlg;
iOldPos = m_ListServers.GetNextItem(-1, LVNI_SELECTED);
if (iOldPos == -1)
return;
dwUnique = m_ListServers.GetItemData(iOldPos);
// Need to look for server data that matches this one
// Now iterate through the server list and add the servers to the
// list box
for (pServer = m_ServerList.GetNextServer(TRUE); pServer;
pServer = m_ServerList.GetNextServer(FALSE) )
{
if (pServer->dwUnique == (DWORD) dwUnique)
break;
}
if (!pServer)
{
Panic0("We can't find the server in the list (but we should)!");
return;
}
pServerDlg->SetDefault(pServer);
if (pServerDlg->DoModal() == IDOK)
{
ZeroMemory(&server, sizeof(server));
pServerDlg->GetDefault(&server);
// Add to the server list, need to add this at the proper place
m_ServerList.AddServer(&server, dwUnique);
// Delete the old server data
m_ServerList.DeleteServer(dwUnique, FALSE);
m_ListServers.DeleteItem(iOldPos);
pServer = NULL;
// Add to the list control
TCHAR szBuf[SCORE_MAX_DIGITS];
LV_ITEM lvItem;
lvItem.mask = LVIF_TEXT | LVIF_PARAM;
lvItem.stateMask = LVIS_FOCUSED | LVIS_SELECTED;
lvItem.state = 0;
lvItem.iItem = iOldPos;
lvItem.iSubItem = 0;
lvItem.pszText = server.szName;
lvItem.lParam = server.dwUnique; //same functionality as SetItemData()
iPos = m_ListServers.InsertItem(&lvItem);
_itot(server.cScore, szBuf, 10);
m_ListServers.SetItemText(iPos, 1, szBuf);
if (iPos != -1)
{
// Reset the current selection
m_ListServers.SetItemState(iPos, LVIS_SELECTED, LVIS_SELECTED);
m_ListServers.SortItems(RadiusScoreCompareProc, (LPARAM)&m_ServerList);
}
ZeroMemory(&server, sizeof(server));
}
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::OnListDblClk
-
Author: KennT
---------------------------------------------------------------------------*/
void RadiusServerDialog::OnListDblClk(NMHDR *pNMHdr, LRESULT *pResult)
{
OnBtnEdit();
}
/*!--------------------------------------------------------------------------
RadiusServerDialog::OnNotifyListItemChanged
-
Author: KennT
---------------------------------------------------------------------------*/
void RadiusServerDialog::OnNotifyListItemChanged(NMHDR *pNMHdr, LRESULT *pResult)
{
NMLISTVIEW * pnmlv = reinterpret_cast<NMLISTVIEW *>(pNMHdr);
int iPos;
if ((pnmlv->uNewState & LVIS_SELECTED) != (pnmlv->uOldState & LVIS_SELECTED))
{
iPos = m_ListServers.GetNextItem(-1, LVNI_SELECTED);
GetDlgItem(IDC_RADAUTH_BTN_DELETE)->EnableWindow(iPos != -1);
GetDlgItem(IDC_RADAUTH_BTN_EDIT)->EnableWindow(iPos != -1);
}
*pResult = 0;
}
//**
//
// Call: LoadRadiusServers
//
// Returns: NO_ERROR - Success
// Non-zero returns - Failure
//
// Description:
//
HRESULT
LoadRadiusServers(
IN LPCTSTR pszServerName,
IN HKEY hkeyMachine,
IN BOOL fAuthentication,
IN CRadiusServers * pRadiusServers,
IN DWORD dwFlags
)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hr = hrOK;
DWORD dwErrorCode;
BOOL fValidServer = FALSE;
RegKey regkeyServers;
RegKeyIterator regkeyIter;
HRESULT hrIter;
CString stKey;
RegKey regkeyServer;
DWORD dwData;
WSADATA wsadata;
BOOL fWSInitialized = FALSE;
DWORD wsaerr = 0;
COM_PROTECT_TRY
{
// DWORD dwKeyIndex, cbKeyServer, cbValue;
// TCHAR szKeyServer[MAX_PATH+1];
CHAR szName[MAX_PATH+1];
RADIUSSERVER RadiusServer;
CWaitCursor waitCursor;
ZeroMemory(&RadiusServer, sizeof(RadiusServer));
Assert(pRadiusServers != NULL);
Assert(hkeyMachine);
wsaerr = WSAStartup(0x0101, &wsadata);
if (wsaerr)
{
// Need to setup a winsock error
hr = E_FAIL;
goto Error;
}
// Winsock successfully initialized
fWSInitialized = TRUE;
CWRg( regkeyServers.Open(hkeyMachine,
fAuthentication ?
c_szRadiusAuthServersKey :
c_szRadiusAcctServersKey,
KEY_READ) );
CORg( regkeyIter.Init(&regkeyServers) );
for (hrIter=regkeyIter.Next(&stKey); hrIter == hrOK;
hrIter=regkeyIter.Next(&stKey), regkeyServer.Close())
{
CWRg( regkeyServer.Open(regkeyServers, stKey, KEY_READ) );
ZeroMemory( &RadiusServer, sizeof( RadiusServer ) );
// Copy the name over
StrnCpy(RadiusServer.szName, stKey, MAX_PATH);
// Since we're reading this in from the registry, it's
// been persisted
RadiusServer.fPersisted = TRUE;
// Get the timeout value
dwErrorCode = regkeyServer.QueryValue(c_szTimeout, dwData);
if ( dwErrorCode != NO_ERROR )
RadiusServer.Timeout.tv_sec = DEFTIMEOUT;
else
RadiusServer.Timeout.tv_sec = dwData;
//
// Secret Value is required
//
CWRg( RetrievePrivateData( pszServerName,
RadiusServer.szName,
RadiusServer.wszSecret,
DimensionOf(RadiusServer.wszSecret)) );
RadiusServer.cchSecret = lstrlen(RadiusServer.wszSecret);
// Encode the password, do not store it as plain text
// Decode as needed.
RadiusServer.ucSeed = ENCRYPT_SEED;
RtlEncodeW(&RadiusServer.ucSeed, RadiusServer.wszSecret);
//
// read in port numbers
//
// Get the AuthPort
if (fAuthentication)
{
dwErrorCode = regkeyServer.QueryValue( c_szAuthPort, dwData );
if ( dwErrorCode != NO_ERROR )
RadiusServer.AuthPort = DEFAUTHPORT;
else
RadiusServer.AuthPort = dwData;
// Windows NT Bug : 311398
// Get the Digital Signature data
if (dwErrorCode == NO_ERROR)
dwErrorCode = regkeyServer.QueryValue( c_szRegValSendSignature, dwData );
if (dwErrorCode == NO_ERROR)
RadiusServer.fUseDigitalSignatures = dwData;
else
RadiusServer.fUseDigitalSignatures = FALSE;
}
else
{
// Get the AcctPort
dwErrorCode = regkeyServer.QueryValue(c_szAcctPort, dwData );
if ( dwErrorCode != NO_ERROR )
RadiusServer.AcctPort = DEFACCTPORT;
else
RadiusServer.AcctPort = dwData;
// Get the EnableAccounting On/Off flag
dwErrorCode = regkeyServer.QueryValue( c_szEnableAccountingOnOff,
dwData );
if ( dwErrorCode != NO_ERROR )
RadiusServer.fAccountingOnOff = TRUE;
else
RadiusServer.fAccountingOnOff = dwData;
}
// Get the score
dwErrorCode = regkeyServer.QueryValue( c_szScore, dwData );
if ( dwErrorCode != NO_ERROR )
RadiusServer.cScore = MAXSCORE;
else
RadiusServer.cScore = dwData;
RadiusServer.cRetries = 1;
//
// Convert name to ip address.
//
if ( INET_ADDR( RadiusServer.szName ) == INADDR_NONE )
{
// resolve name
struct hostent * phe = NULL;
if (dwFlags & RADIUS_FLAG_NOIP)
phe = NULL;
else
{
StrnCpyAFromT(szName, RadiusServer.szName,
DimensionOf(szName));
phe = gethostbyname( szName );
}
if ( phe != NULL )
{
// host could have multiple addresses
// BUG#185732 (nsun 11/04/98) We only load the first Ip Address
if( phe->h_addr_list[0] != NULL )
{
RadiusServer.IPAddress.sin_family = AF_INET;
RadiusServer.IPAddress.sin_port =
htons((SHORT) RadiusServer.AuthPort);
RadiusServer.IPAddress.sin_addr.S_un.S_addr =
*((PDWORD) phe->h_addr_list[0]);
}
}
else
{
if ((dwFlags & RADIUS_FLAG_NOUI) == 0)
{
CString stText;
stText.Format(IDS_ERR_RADIUS_INVALID_NAME, RadiusServer.szName);
AfxMessageBox((LPCTSTR)stText, MB_OK | MB_ICONEXCLAMATION);
waitCursor.Restore();
}
}
}
else
{
//
// use specified ip address
//
RadiusServer.IPAddress.sin_family = AF_INET;
RadiusServer.IPAddress.sin_port =
htons((SHORT) RadiusServer.AuthPort);
RadiusServer.IPAddress.sin_addr.S_un.S_addr = INET_ADDR(RadiusServer.szName);
}
if ( pRadiusServers != NULL )
{
fValidServer = (pRadiusServers->AddServer(&RadiusServer, (DWORD) -1)
== NO_ERROR
? TRUE
: FALSE);
}
}
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
if (fWSInitialized)
WSACleanup();
//
// if no servers entries are found in registry return error code.
//
if ( ( fValidServer == FALSE ) && FHrSucceeded(hr) )
{
hr = HRESULT_FROM_WIN32(ERROR_NO_RADIUS_SERVERS);
}
return( hr );
}
//**
//
// Call: SaveRadiusServers
//
// Returns: NO_ERROR - Success
// Non-zero returns - Failure
//
// Description:
//
HRESULT
SaveRadiusServers(LPCTSTR pszServerName,
HKEY hkeyMachine,
IN BOOL fAuthentication,
IN RADIUSSERVER * pServerRoot
)
{
HRESULT hr = hrOK;
RADIUSSERVER *pServer;
DWORD dwErrorCode;
RegKey regkeyMachine;
RegKey regkeyServers, regkeyServer;
DWORD dwData;
pServer = pServerRoot;
COM_PROTECT_TRY
{
regkeyMachine.Attach(hkeyMachine);
regkeyMachine.RecurseDeleteKey(fAuthentication ?
c_szRadiusAuthServersKey :
c_szRadiusAcctServersKey);
CWRg( regkeyServers.Create(hkeyMachine,
fAuthentication ?
c_szRadiusAuthServersKey :
c_szRadiusAcctServersKey) );
while( pServer != NULL )
{
CWRg( regkeyServer.Create(regkeyServers, pServer->szName) );
// Need to unencode the private data
RtlDecodeW(pServer->ucSeed, pServer->wszSecret);
dwErrorCode = StorePrivateData(pszServerName,
pServer->szName,
pServer->wszSecret);
RtlEncodeW(&pServer->ucSeed, pServer->wszSecret);
CWRg( dwErrorCode );
// Ok, we've saved the information
pServer->fPersisted = TRUE;
dwData = pServer->Timeout.tv_sec;
CWRg( regkeyServer.SetValue(c_szTimeout, dwData) );
if (fAuthentication)
{
dwData = pServer->AuthPort;
CWRg( regkeyServer.SetValue(c_szAuthPort, dwData) );
// Windows NT Bug: 311398
// Save the digital signature data
dwData = pServer->fUseDigitalSignatures;
CWRg( regkeyServer.SetValue(c_szRegValSendSignature, dwData) );
}
else
{
dwData = pServer->AcctPort;
CWRg( regkeyServer.SetValue(c_szAcctPort, dwData) );
dwData = pServer->fAccountingOnOff;
CWRg( regkeyServer.SetValue(c_szEnableAccountingOnOff, dwData) );
}
dwData = pServer->cScore;
CWRg( regkeyServer.SetValue(c_szScore, dwData) );
regkeyServer.Close();
pServer = pServer->pNext;
}
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
regkeyMachine.Detach();
return hr;
}
/*!--------------------------------------------------------------------------
DeleteRadiusServers
DANGER! Do NOT call this unless you absolutely know this is
what you need. The problem is that there is no way to
distinguish between accouting/authentication entries, thus an
external reference check must be made.
Author: KennT
---------------------------------------------------------------------------*/
HRESULT
DeleteRadiusServers(LPCTSTR pszServerName,
RADIUSSERVER * pServerRoot
)
{
HRESULT hr = hrOK;
RADIUSSERVER *pServer;
pServer = pServerRoot;
COM_PROTECT_TRY
{
while( pServer != NULL )
{
if (pServer->fPersisted)
DeletePrivateData(pszServerName,
pServer->szName);
pServer = pServer->pNext;
}
}
COM_PROTECT_CATCH;
return hr;
}
/*---------------------------------------------------------------------------
ServerPropDialog implementation
---------------------------------------------------------------------------*/
ServerPropDialog::ServerPropDialog(BOOL fEdit, CWnd* pParent /*=NULL*/)
: CBaseDialog(ServerPropDialog::IDD, pParent),
m_fEdit(fEdit)
{
//{{AFX_DATA_INIT(ServerPropDialog)
m_uAuthPort = DEFAUTHPORT;
m_uAcctPort = DEFACCTPORT;
m_stSecret.Empty();
m_cchSecret = 0;
m_ucSeed = ENCRYPT_SEED;
m_stServer.Empty();
m_uTimeout = DEFTIMEOUT;
m_iInitScore = MAXSCORE;
m_fAccountingOnOff = FALSE;
m_fUseDigitalSignatures = FALSE;
//}}AFX_DATA_INIT
}
ServerPropDialog::ServerPropDialog(BOOL fEdit, UINT idd, CWnd* pParent /*=NULL*/)
: CBaseDialog(idd, pParent),
m_fEdit(fEdit)
{
//{{AFX_DATA_INIT(ServerPropDialog)
m_uAuthPort = DEFAUTHPORT;
m_uAcctPort = DEFACCTPORT;
m_stSecret.Empty();
m_cchSecret = 0;
m_ucSeed = ENCRYPT_SEED;
m_stServer.Empty();
m_uTimeout = DEFTIMEOUT;
m_iInitScore = MAXSCORE;
m_fAccountingOnOff = FALSE;
m_fUseDigitalSignatures = FALSE;
//}}AFX_DATA_INIT
}
ServerPropDialog::~ServerPropDialog()
{
ZeroMemory(m_stSecret.GetBuffer(0),
m_stSecret.GetLength() * sizeof(TCHAR));
m_stSecret.ReleaseBuffer(-1);
}
void ServerPropDialog::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(ServerPropDialog)
DDX_Control(pDX, IDC_RAC_EDIT_SERVER, m_editServerName);
DDX_Control(pDX, IDC_RAC_EDIT_SECRET, m_editSecret);
DDX_Control(pDX, IDC_RAC_EDIT_PORT, m_editPort);
DDX_Control(pDX, IDC_RAC_SPIN_SCORE, m_spinScore);
DDX_Control(pDX, IDC_RAC_SPIN_TIMEOUT, m_spinTimeout);
DDX_Text(pDX, IDC_RAC_EDIT_PORT, m_uAuthPort);
DDX_Text(pDX, IDC_RAC_EDIT_SERVER, m_stServer);
DDX_Text(pDX, IDC_RAC_EDIT_TIMEOUT, m_uTimeout);
DDX_Text(pDX, IDC_RAC_EDIT_SCORE, m_iInitScore);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(ServerPropDialog, CBaseDialog)
//{{AFX_MSG_MAP(ServerPropDialog)
ON_BN_CLICKED(IDC_RAC_BTN_CHANGE, OnBtnPassword)
// ON_WM_CONTEXTMENU()
// ON_WM_HELPINFO()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// ServerPropDialog message handlers
/*!--------------------------------------------------------------------------
ServerPropDialog::SetDefault
-
Author: KennT
---------------------------------------------------------------------------*/
VOID ServerPropDialog::SetDefault(RADIUSSERVER *pServer)
{
Assert(pServer);
m_stServer = pServer->szName;
m_stSecret = pServer->wszSecret;
m_ucSeed = pServer->ucSeed;
m_cchSecret = pServer->cchSecret;
m_uTimeout = pServer->Timeout.tv_sec;
m_uAcctPort = pServer->AcctPort;
m_uAuthPort = pServer->AuthPort;
m_iInitScore = pServer->cScore;
m_fAccountingOnOff = pServer->fAccountingOnOff;
m_fUseDigitalSignatures = pServer->fUseDigitalSignatures;
} // SetDefault()
/*!--------------------------------------------------------------------------
ServerPropDialog::GetDefault
-
Author: KennT
---------------------------------------------------------------------------*/
VOID ServerPropDialog::GetDefault(RADIUSSERVER *pServer)
{
Assert(pServer);
lstrcpy(pServer->szName, m_stServer);
lstrcpy(pServer->wszSecret, m_stSecret);
pServer->cchSecret = m_stSecret.GetLength();
pServer->ucSeed = m_ucSeed;
pServer->Timeout.tv_sec = m_uTimeout;
pServer->AcctPort = m_uAcctPort;
pServer->AuthPort = m_uAuthPort;
pServer->cScore = m_iInitScore;
pServer->fAccountingOnOff = m_fAccountingOnOff;
pServer->fUseDigitalSignatures = m_fUseDigitalSignatures;
} // GetDefault()
/*!--------------------------------------------------------------------------
ServerPropDialog::OnInitDialog
-
Author: KennT
---------------------------------------------------------------------------*/
BOOL ServerPropDialog::OnInitDialog()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CString stTitle;
CBaseDialog::OnInitDialog();
// Set the title of this dialog
stTitle.LoadString(m_fEdit ? IDS_RADIUS_CONFIG_EDIT : IDS_RADIUS_CONFIG_ADD);
SetWindowText(stTitle);
m_editServerName.SetFocus();
// We don't allow editing of the secret from here
m_editSecret.EnableWindow(FALSE);
// Need to send 'cchSecret' backspace characters to the
// edit control. Do this so that it looks as if there are
// the right number of characters
//
// Windows NT Bug : 186649 - we should show the same number of
// characters regardless.
//
// If this is a new server, then we keep the secret text as
// blank, so the user knows that there is no secret. In the
// edit case, we still show the text even if the secret is blank.
// ----------------------------------------------------------------
if (m_fEdit)
m_editSecret.SetWindowText(c_szDisplayedSecret);
m_spinScore.SetBuddy(GetDlgItem(IDC_RAC_EDIT_SCORE));
m_spinScore.SetRange(0, MAXSCORE);
m_spinTimeout.SetBuddy(GetDlgItem(IDC_RAC_EDIT_TIMEOUT));
m_spinTimeout.SetRange(0, 300);
if (GetDlgItem(IDC_RAC_BTN_DIGITALSIG))
CheckDlgButton(IDC_RAC_BTN_DIGITALSIG, m_fUseDigitalSignatures);
return FALSE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
/*!--------------------------------------------------------------------------
ServerPropDialog::OnOK
-
Author: KennT
---------------------------------------------------------------------------*/
void ServerPropDialog::OnOK()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CString stTemp;
if (!UpdateData(TRUE))
return;
// Do parameter checking
m_editServerName.GetWindowText(stTemp);
stTemp.TrimLeft();
stTemp.TrimRight();
if (stTemp.IsEmpty())
{
AfxMessageBox(IDS_ERR_INVALID_SERVER_NAME);
m_editServerName.SetFocus();
return;
}
// Need to grab the current value of the secret out of the edit
// control. If there are only backspace characters, then do
// not change the secret. Otherwise overwrite the current secret.
// m_editSecret.GetWindowText(stTemp);
// for (int i=0; i<stTemp.GetLength(); i++)
// {
// if (stTemp[i] != _T('\b'))
// {
// // Ok, the secret has changed, use the new password instead
// RtlEncodeW(&m_ucSeed, stTemp.GetBuffer(0));
// stTemp.ReleaseBuffer(-1);
//
// // Get a pointer to the old memory and write 0's into it
// ZeroMemory(m_stSecret.GetBuffer(0),
// m_stSecret.GetLength() * sizeof(TCHAR));
// m_stSecret.ReleaseBuffer(-1);
//
// m_stSecret = stTemp;
// break;
// }
// }
// m_fAuthentication = IsDlgButtonChecked(IDC_RAC_BTN_ENABLE);
if (GetDlgItem(IDC_RAC_BTN_DIGITALSIG))
m_fUseDigitalSignatures = IsDlgButtonChecked(IDC_RAC_BTN_DIGITALSIG);
if (m_iInitScore > MAXSCORE || m_iInitScore < MINSCORE)
{
CString stErrMsg;
stErrMsg.Format(IDS_ERR_INVALID_RADIUS_SCORE, m_iInitScore, MINSCORE, MAXSCORE);
AfxMessageBox((LPCTSTR)stErrMsg);
}
else
CBaseDialog::OnOK();
}
/*!--------------------------------------------------------------------------
ServerPropDialog::OnBtnPassword
-
Author: KennT
---------------------------------------------------------------------------*/
void ServerPropDialog::OnBtnPassword()
{
RADIUSSecretDialog secretdlg;
// Ask for the new secret
if (secretdlg.DoModal() == IDOK)
{
// Zero out the old value
ZeroMemory(m_stSecret.GetBuffer(0),
m_stSecret.GetLength() * sizeof(TCHAR));
m_stSecret.ReleaseBuffer(-1);
// Get the value of the new secret and seed
secretdlg.GetSecret(&m_stSecret, &m_cchSecret, &m_ucSeed);
// Windows NT Bug : 186649
// Must show secrets as constant length.
m_editSecret.SetWindowText(c_szDisplayedSecret);
}
}
//static const DWORD rgHelpIDs[] =
// {
// IDC_EDIT_SERVERNAME, IDH_SERVER_NAME,
// IDC_EDIT_SECRET, IDH_SECRET,
// IDC_EDIT_TIMEOUT, IDH_TIMEOUT,
// IDC_SPIN_TIMEOUT, IDH_TIMEOUT,
// IDC_EDIT_SCORE, IDH_INITIAL_SCORE,
// IDC_SPIN_SCORE, IDH_INITIAL_SCORE,
// IDC_CHECK_ACCT, IDH_ENABLE_ACCOUNTING,
// IDC_STATIC_ACCTPORT, IDH_ACCOUNTING_PORT,
// IDC_EDIT_ACCTPORT, IDH_ACCOUNTING_PORT,
// IDC_CHECK_AUTH, IDH_ENABLE_AUTHENTICATION,
// IDC_STATIC_AUTHPORT, IDH_AUTHENTICATION_PORT,
// IDC_EDIT_AUTHPORT, IDH_AUTHENTICATION_PORT,
// IDC_CHECK_ACCT_ONOFF, IDH_ACCOUNTING_ONOFF,
// 0, 0
//};
/*---------------------------------------------------------------------------
RADIUSSecretDialog implementation
---------------------------------------------------------------------------*/
RADIUSSecretDialog::RADIUSSecretDialog(CWnd* pParent /*=NULL*/)
: CBaseDialog(RADIUSSecretDialog::IDD, pParent)
{
//{{AFX_DATA_INIT(RADIUSSecretDialog)
//}}AFX_DATA_INIT
m_cchNewSecret = 0;
m_stNewSecret.Empty();
m_ucNewSeed = 0;
}
RADIUSSecretDialog::~RADIUSSecretDialog()
{
ZeroMemory(m_stNewSecret.GetBuffer(0),
m_stNewSecret.GetLength() * sizeof(TCHAR));
m_stNewSecret.ReleaseBuffer(-1);
}
void RADIUSSecretDialog::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(RADIUSSecretDialog)
DDX_Control(pDX, IDC_SECRET_EDIT_NEW, m_editSecretNew);
DDX_Control(pDX, IDC_SECRET_EDIT_NEW_CONFIRM, m_editSecretNewConfirm);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(RADIUSSecretDialog, CBaseDialog)
//{{AFX_MSG_MAP(RADIUSSecretDialog)
// ON_WM_CONTEXTMENU()
// ON_WM_HELPINFO()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// RADIUSSecretDialog message handlers
/*!--------------------------------------------------------------------------
RADIUSSecretDialog::GetSecret
-
Author: KennT
---------------------------------------------------------------------------*/
VOID RADIUSSecretDialog::GetSecret(CString *pst, INT *pcch, UCHAR *pucSeed)
{
*pst = m_stNewSecret;
*pcch = m_cchNewSecret;
*pucSeed = m_ucNewSeed;
}
/*!--------------------------------------------------------------------------
RADIUSSecretDialog::OnInitDialog
-
Author: KennT
---------------------------------------------------------------------------*/
BOOL RADIUSSecretDialog::OnInitDialog()
{
CBaseDialog::OnInitDialog();
m_editSecretNew.SetWindowText(c_szEmpty);
m_editSecretNewConfirm.SetWindowText(c_szEmpty);
return FALSE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
/*!--------------------------------------------------------------------------
RADIUSSecretDialog::OnOK
-
Author: KennT
---------------------------------------------------------------------------*/
void RADIUSSecretDialog::OnOK()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
CString stTemp;
CString stNew, stNewConfirm, stOld;
UCHAR ucSeed;
// Get the text for the new password, compare it to the
// new confirm passord, if they are the same use that as
// the password.
GetDlgItemText(IDC_SECRET_EDIT_NEW, stNew);
GetDlgItemText(IDC_SECRET_EDIT_NEW_CONFIRM, stNewConfirm);
if (stNew != stNewConfirm)
{
AfxMessageBox(IDS_ERR_SECRETS_MUST_MATCH);
return;
}
// Zero out the old value
ZeroMemory(m_stNewSecret.GetBuffer(0),
m_stNewSecret.GetLength() * sizeof(TCHAR));
m_stNewSecret.ReleaseBuffer(-1);
// Get the new values (and encrypt)
m_stNewSecret = stNew;
m_ucNewSeed = ENCRYPT_SEED;
RtlEncodeW(&m_ucNewSeed, m_stNewSecret.GetBuffer(0));
m_stNewSecret.ReleaseBuffer(-1);
m_cchNewSecret = m_stNewSecret.GetLength();
// Zero out the on-stack memory
ZeroMemory(stNew.GetBuffer(0),
stNew.GetLength() * sizeof(TCHAR));
stNew.ReleaseBuffer(-1);
ZeroMemory(stNewConfirm.GetBuffer(0),
stNewConfirm.GetLength() * sizeof(TCHAR));
stNewConfirm.ReleaseBuffer(-1);
// Need to grab the current value of the secret out of the edit
// control. If there are only backspace characters, then do
// not change the secret. Otherwise overwrite the current secret.
// m_editSecret.GetWindowText(stTemp);
// for (int i=0; i<stTemp.GetLength(); i++)
// {
// if (stTemp[i] != _T('\b'))
// {
// // Ok, the secret has changed, use the new password instead
// RtlEncodeW(&m_ucSeed, stTemp.GetBuffer(0));
// stTemp.ReleaseBuffer(-1);
//
// // Get a pointer to the old memory and write 0's into it
// ZeroMemory(m_stSecret.GetBuffer(0),
// m_stSecret.GetLength() * sizeof(TCHAR));
// m_stSecret.ReleaseBuffer(-1);
//
// m_stSecret = stTemp;
// break;
// }
// }
CBaseDialog::OnOK();
}
/*---------------------------------------------------------------------------
RouterAcctRadiusConfig implementation
---------------------------------------------------------------------------*/
/*!--------------------------------------------------------------------------
RouterAcctRadiusConfig::Initialize
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAcctRadiusConfig::Initialize(LPCOLESTR pszMachineName,
ULONG_PTR *puConnection)
{
HRESULT hr = hrOK;
// Parameter checking
// ----------------------------------------------------------------
if (puConnection == NULL)
return E_INVALIDARG;
COM_PROTECT_TRY
{
// for now, allocate a string and have it point at the string
// ------------------------------------------------------------
*puConnection = (ULONG_PTR) StrDupTFromOle(pszMachineName);
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterAcctRadiusConfig::Uninitialize
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAcctRadiusConfig::Uninitialize(ULONG_PTR uConnection)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
delete (TCHAR *) uConnection;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterAcctRadiusConfig::Configure
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAcctRadiusConfig::Configure(
ULONG_PTR uConnection,
HWND hWnd,
DWORD dwFlags,
ULONG_PTR uReserved1,
ULONG_PTR uReserved2)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
RadiusServerDialog acctDlg(FALSE, IDS_RADIUS_SERVER_ACCT_TITLE);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
acctDlg.SetServer((TCHAR *) uConnection);
acctDlg.DoModal();
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterAcctRadiusConfig::Activate
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAcctRadiusConfig::Activate(
ULONG_PTR uConnection,
ULONG_PTR uReserved1,
ULONG_PTR uReserved2)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterAcctRadiusConfig::Deactivate
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterAcctRadiusConfig::Deactivate(
ULONG_PTR uConnection,
ULONG_PTR uReserved1,
ULONG_PTR uReserved2)
{
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
}
COM_PROTECT_CATCH;
return hr;
}
/*---------------------------------------------------------------------------
ServerPropAcctDialog implementation
---------------------------------------------------------------------------*/
ServerPropAcctDialog::ServerPropAcctDialog(BOOL fEdit, CWnd* pParent /*=NULL*/)
: ServerPropDialog(fEdit, ServerPropAcctDialog::IDD, pParent)
{
//{{AFX_DATA_INIT(ServerPropAcctDialog)
//}}AFX_DATA_INIT
}
ServerPropAcctDialog::~ServerPropAcctDialog()
{
}
void ServerPropAcctDialog::DoDataExchange(CDataExchange* pDX)
{
ServerPropDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(ServerPropAcctDialog)
DDX_Text(pDX, IDC_RAC_EDIT_PORT, m_uAcctPort);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(ServerPropAcctDialog, CBaseDialog)
//{{AFX_MSG_MAP(ServerPropAcctDialog)
ON_BN_CLICKED(IDC_RAC_BTN_CHANGE, OnBtnPassword)
// ON_WM_CONTEXTMENU()
// ON_WM_HELPINFO()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// ServerPropAcctDialog message handlers
/*!--------------------------------------------------------------------------
ServerPropAcctDialog::OnInitDialog
-
Author: KennT
---------------------------------------------------------------------------*/
BOOL ServerPropAcctDialog::OnInitDialog()
{
ServerPropDialog::OnInitDialog();
CheckDlgButton(IDC_RAC_BTN_ONOFF, m_fAccountingOnOff);
return FALSE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
/*!--------------------------------------------------------------------------
ServerPropAcctDialog::OnOK
-
Author: KennT
---------------------------------------------------------------------------*/
void ServerPropAcctDialog::OnOK()
{
CString stTemp;
// Need to grab the current value of the secret out of the edit
// control. If there are only backspace characters, then do
// not change the secret. Otherwise overwrite the current secret.
// m_editSecret.GetWindowText(stTemp);
// for (int i=0; i<stTemp.GetLength(); i++)
// {
// if (stTemp[i] != _T('\b'))
// {
// // Ok, the secret has changed, use the new password instead
// RtlEncodeW(&m_ucSeed, stTemp.GetBuffer(0));
// stTemp.ReleaseBuffer(-1);
//
// // Get a pointer to the old memory and write 0's into it
// ZeroMemory(m_stSecret.GetBuffer(0),
// m_stSecret.GetLength() * sizeof(TCHAR));
// m_stSecret.ReleaseBuffer(-1);
//
// m_stSecret = stTemp;
// break;
// }
// }
m_fAccountingOnOff = IsDlgButtonChecked(IDC_RAC_BTN_ONOFF);
ServerPropDialog::OnOK();
}
//static const DWORD rgHelpIDs[] =
// {
// IDC_EDIT_SERVERNAME, IDH_SERVER_NAME,
// IDC_EDIT_SECRET, IDH_SECRET,
// IDC_EDIT_TIMEOUT, IDH_TIMEOUT,
// IDC_SPIN_TIMEOUT, IDH_TIMEOUT,
// IDC_EDIT_SCORE, IDH_INITIAL_SCORE,
// IDC_SPIN_SCORE, IDH_INITIAL_SCORE,
// IDC_CHECK_ACCT, IDH_ENABLE_ACCOUNTING,
// IDC_STATIC_ACCTPORT, IDH_ACCOUNTING_PORT,
// IDC_EDIT_ACCTPORT, IDH_ACCOUNTING_PORT,
// IDC_CHECK_AUTH, IDH_ENABLE_AUTHENTICATION,
// IDC_STATIC_AUTHPORT, IDH_AUTHENTICATION_PORT,
// IDC_EDIT_AUTHPORT, IDH_AUTHENTICATION_PORT,
// IDC_CHECK_ACCT_ONOFF, IDH_ACCOUNTING_ONOFF,
// 0, 0
//};
Reference in a new issue Copy permalink