You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
456 lines
12 KiB
456 lines
12 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1996.
|
|
//
|
|
// File: ras.c
|
|
//
|
|
// Contents:
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 2-09-96 RichardW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "msgina.h"
|
|
#include <wchar.h>
|
|
#include <wincrypt.h>
|
|
#include <sclogon.h>
|
|
#include <raserror.h>
|
|
|
|
#define NP_Nbf 0x1
|
|
#define NP_Ipx 0x2
|
|
#define NP_Ip 0x4
|
|
|
|
HANDLE hRasApi ;
|
|
|
|
VOID WINAPI
|
|
MyRasCallback(
|
|
IN DWORD_PTR dwCallbackId,
|
|
IN DWORD dwEventCode,
|
|
IN LPWSTR pszEntry,
|
|
IN LPVOID pEventArgs )
|
|
|
|
/* RasPhonebookDlg callback. 'DwCallbackId' is the ID provided in
|
|
** parameters to RasPhonebookDlg. 'DwEventCode' indicates the
|
|
** RASPBDEVENT_* event that has occurred. 'PszEntry' is the name of the
|
|
** entry on which the event occurred. 'PEventArgs' is the event-specific
|
|
** parameter block passed to us during RasPhonebookDlg callback.
|
|
*/
|
|
{
|
|
RASNOUSERW* pInfo;
|
|
PGLOBALS pGlobals;
|
|
|
|
DebugLog((DEB_TRACE, "RasCallback: %#x, %#x, %ws, %#x\n",
|
|
dwCallbackId, dwEventCode, pszEntry, pEventArgs ));
|
|
|
|
|
|
/* Fill in information about the not yet logged on user.
|
|
*/
|
|
pInfo = (RASNOUSERW* )pEventArgs;
|
|
pGlobals = (PGLOBALS) dwCallbackId;
|
|
|
|
|
|
if (dwEventCode == RASPBDEVENT_NoUserEdit)
|
|
{
|
|
if (pInfo->szUserName[0])
|
|
{
|
|
wcscpy( pGlobals->UserName, pInfo->szUserName );
|
|
}
|
|
|
|
if (pInfo->szPassword[0])
|
|
{
|
|
wcscpy( pGlobals->Password, pInfo->szPassword );
|
|
RtlInitUnicodeString( &pGlobals->PasswordString, pGlobals->Password );
|
|
|
|
pGlobals->Seed = 0;
|
|
|
|
HidePassword( &pGlobals->Seed, &pGlobals->PasswordString );
|
|
}
|
|
|
|
}
|
|
else if (dwEventCode == RASPBDEVENT_NoUser)
|
|
|
|
{
|
|
|
|
ZeroMemory( pInfo, sizeof( RASNOUSERW ) );
|
|
|
|
pInfo->dwTimeoutMs = 2 * 60 * 1000;
|
|
pInfo->dwSize = sizeof( RASNOUSERW );
|
|
wcsncpy( pInfo->szUserName, pGlobals->UserName, UNLEN );
|
|
wcsncpy( pInfo->szDomain, pGlobals->Domain, DNLEN );
|
|
|
|
RevealPassword( &pGlobals->PasswordString );
|
|
wcsncpy( pInfo->szPassword, pGlobals->Password, PWLEN );
|
|
|
|
HidePassword( &pGlobals->Seed, &pGlobals->PasswordString );
|
|
|
|
}
|
|
|
|
if( pGlobals->SmartCardLogon
|
|
&& (NULL != pInfo))
|
|
{
|
|
pInfo->dwFlags |= RASNOUSER_SmartCard;
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
GetRasDialOutProtocols(
|
|
void )
|
|
|
|
/* Returns a bit field containing NP_<protocol> flags for the installed
|
|
** PPP protocols. The term "installed" here includes enabling in RAS
|
|
** Setup.
|
|
*/
|
|
{
|
|
|
|
//
|
|
// Since after the connections checkin, RAS is always installed
|
|
// and there is no way to uninstall it, all we need to check here
|
|
// is if there are protocols installed that can be used by RAS to
|
|
// dial out. By default any protocol installed is available for RAS
|
|
// to dial out on. This can be overridden from the phonebook entry.
|
|
//
|
|
|
|
static const TCHAR c_szRegKeyIp[] =
|
|
TEXT("SYSTEM\\CurrentControlSet\\Services\\Tcpip");
|
|
|
|
static const TCHAR c_szRegKeyIpx[] =
|
|
TEXT("SYSTEM\\CurrentControlSet\\Services\\NwlnkIpx");
|
|
|
|
static const TCHAR c_szRegKeyNbf[] =
|
|
TEXT("SYSTEM\\CurrentControlSet\\Services\\Nbf");
|
|
|
|
struct PROTOCOL_INFO
|
|
{
|
|
DWORD dwFlag;
|
|
LPCTSTR pszRegkey;
|
|
};
|
|
|
|
static const struct PROTOCOL_INFO c_aProtocolInfo[] =
|
|
{
|
|
{
|
|
NP_Ip,
|
|
c_szRegKeyIp,
|
|
},
|
|
|
|
{
|
|
NP_Ipx,
|
|
c_szRegKeyIpx,
|
|
},
|
|
|
|
{
|
|
NP_Nbf,
|
|
c_szRegKeyNbf,
|
|
},
|
|
};
|
|
|
|
DWORD dwfInstalledProtocols = 0;
|
|
DWORD dwNumProtocols = sizeof(c_aProtocolInfo)/sizeof(c_aProtocolInfo[0]);
|
|
DWORD i;
|
|
HKEY hkey;
|
|
|
|
|
|
DebugLog(( DEB_TRACE, "GetRasDialOutProtocols...\n" ));
|
|
|
|
for(i = 0; i < dwNumProtocols; i++)
|
|
{
|
|
if(0 == RegOpenKey(HKEY_LOCAL_MACHINE,
|
|
c_aProtocolInfo[i].pszRegkey,
|
|
&hkey))
|
|
{
|
|
dwfInstalledProtocols |= c_aProtocolInfo[i].dwFlag;
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
|
|
DebugLog(( DEB_TRACE, "GetRasDialOutProtocols: dwfInstalledProtocols=0x%x\n",
|
|
dwfInstalledProtocols));
|
|
|
|
return dwfInstalledProtocols;
|
|
}
|
|
|
|
|
|
BOOL
|
|
PopupRasPhonebookDlg(
|
|
IN HWND hwndOwner,
|
|
IN PGLOBALS pGlobals,
|
|
OUT BOOL* pfTimedOut
|
|
)
|
|
|
|
/* Popup the RAS common phonebook dialog to let user establish connection.
|
|
** 'HwndOwner' is the window to own the RAS dialog or NULL if none. '*PfTimedOut' is
|
|
** set TRUE if the dialog timed out, false otherwise.
|
|
**
|
|
** Returns true if user made a connection, false if not, i.e. an error
|
|
** occurred, RAS is not installed or user could not or chose not to
|
|
** connect.
|
|
*/
|
|
{
|
|
BOOL fConnected;
|
|
RASPBDLG info;
|
|
DWORD Protocols;
|
|
PUCHAR pvScData = NULL;
|
|
|
|
struct EAPINFO
|
|
{
|
|
DWORD dwSizeofEapInfo;
|
|
PBYTE pbEapInfo;
|
|
DWORD dwSizeofPINInfo;
|
|
PBYTE pbPINInfo;
|
|
};
|
|
|
|
struct EAPINFO eapinfo;
|
|
struct EAPINFO *pEapInfo = NULL;
|
|
|
|
*pfTimedOut = FALSE;
|
|
|
|
Protocols = GetRasDialOutProtocols();
|
|
if (Protocols == 0)
|
|
{
|
|
return( FALSE );
|
|
}
|
|
|
|
if(pGlobals->SmartCardLogon)
|
|
{
|
|
PULONG pulScData;
|
|
|
|
struct FLAT_UNICODE_STRING
|
|
{
|
|
USHORT Length;
|
|
USHORT MaximumLength;
|
|
BYTE abdata[1];
|
|
};
|
|
|
|
struct FLAT_UNICODE_STRING *pFlatUnicodeString;
|
|
PWLX_SC_NOTIFICATION_INFO ScInfo = NULL ;
|
|
|
|
//
|
|
// Get the set of strings indicating the reader and CSP
|
|
// to be used for the smart card. We will pass this info
|
|
// down to RAS.
|
|
//
|
|
pWlxFuncs->WlxGetOption( pGlobals->hGlobalWlx,
|
|
WLX_OPTION_SMART_CARD_INFO,
|
|
(ULONG_PTR *) &ScInfo);
|
|
|
|
if ( !ScInfo )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Validate the SC info against some common user
|
|
// errors
|
|
//
|
|
|
|
if ( ( ScInfo->pszReader ) &&
|
|
( ScInfo->pszCard == NULL ) )
|
|
{
|
|
//
|
|
// The card could not be read. Might not be
|
|
// inserted correctly.
|
|
//
|
|
LocalFree(ScInfo);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( ( ScInfo->pszReader ) &&
|
|
( ScInfo->pszCryptoProvider == NULL ) )
|
|
{
|
|
//
|
|
// Got a card, but the CSP for it could not be
|
|
// found.
|
|
//
|
|
LocalFree(ScInfo);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
pvScData = ScBuildLogonInfo(ScInfo->pszCard,
|
|
ScInfo->pszReader,
|
|
ScInfo->pszContainer,
|
|
ScInfo->pszCryptoProvider );
|
|
|
|
LocalFree(ScInfo);
|
|
|
|
if ( ! pvScData )
|
|
{
|
|
return FALSE ;
|
|
}
|
|
|
|
|
|
pulScData = (PULONG) pvScData;
|
|
|
|
ZeroMemory(&eapinfo, sizeof(struct EAPINFO));
|
|
|
|
eapinfo.dwSizeofEapInfo = *pulScData;
|
|
eapinfo.pbEapInfo = (BYTE *) pvScData;
|
|
|
|
eapinfo.dwSizeofPINInfo = sizeof(UNICODE_STRING) +
|
|
(sizeof(TCHAR) *
|
|
(1 + lstrlen(pGlobals->PasswordString.Buffer)));
|
|
|
|
//
|
|
// Flatten out the unicode string.
|
|
//
|
|
pFlatUnicodeString = LocalAlloc(LPTR, eapinfo.dwSizeofPINInfo);
|
|
|
|
if(NULL == pFlatUnicodeString)
|
|
{
|
|
if(NULL != pvScData)
|
|
{
|
|
LocalFree(pvScData);
|
|
}
|
|
return (FALSE);
|
|
}
|
|
|
|
pFlatUnicodeString->Length = pGlobals->PasswordString.Length;
|
|
pFlatUnicodeString->MaximumLength = pGlobals->PasswordString.MaximumLength;
|
|
|
|
lstrcpy((LPTSTR) pFlatUnicodeString->abdata,
|
|
(LPTSTR) pGlobals->PasswordString.Buffer);
|
|
|
|
|
|
eapinfo.pbPINInfo = (BYTE *) pFlatUnicodeString;
|
|
pEapInfo = &eapinfo;
|
|
}
|
|
|
|
ZeroMemory( &info, sizeof(info) );
|
|
info.dwSize = sizeof(info);
|
|
info.hwndOwner = hwndOwner;
|
|
info.dwFlags = RASPBDFLAG_NoUser;
|
|
info.pCallback = MyRasCallback;
|
|
info.dwCallbackId = (ULONG_PTR) pGlobals;
|
|
info.reserved2 = (ULONG_PTR) pEapInfo;
|
|
|
|
fConnected = RasPhonebookDlg( NULL, NULL, &info );
|
|
if (info.dwError == STATUS_TIMEOUT)
|
|
*pfTimedOut = TRUE;
|
|
|
|
if( (pEapInfo)
|
|
&& (pEapInfo->pbPINInfo))
|
|
{
|
|
LocalFree(pEapInfo->pbPINInfo);
|
|
}
|
|
|
|
if(NULL != pvScData)
|
|
{
|
|
LocalFree(pvScData);
|
|
}
|
|
|
|
return fConnected;
|
|
}
|
|
|
|
|
|
BOOL
|
|
IsRASServiceRunning()
|
|
{
|
|
BOOL bRet = FALSE; // assume the service is not running
|
|
SC_HANDLE hServiceMgr;
|
|
|
|
hServiceMgr = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
|
|
|
|
if (hServiceMgr != NULL)
|
|
{
|
|
SC_HANDLE hService = OpenService(hServiceMgr, TEXT("RASMAN"), SERVICE_QUERY_STATUS);
|
|
|
|
if (hService != NULL)
|
|
{
|
|
SERVICE_STATUS status;
|
|
|
|
if (QueryServiceStatus(hService, &status) &&
|
|
(status.dwCurrentState == SERVICE_RUNNING))
|
|
{
|
|
// the RAS service is running
|
|
bRet = TRUE;
|
|
}
|
|
|
|
CloseServiceHandle(hService);
|
|
}
|
|
|
|
CloseServiceHandle(hServiceMgr);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
// we need to treat RAS connections made by the system luid as created by the user.
|
|
// this allows us to "do the right thing" when a connection is made from the C-A-D dialog
|
|
// before any user is logged in
|
|
__inline BOOL IsEqualOrSystemLuid(PLUID pLuid, PLUID pUserLuid)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
static LUID luidSystem = SYSTEM_LUID;
|
|
|
|
if (RtlEqualLuid(pLuid, pUserLuid) || RtlEqualLuid(pLuid, &luidSystem))
|
|
{
|
|
// return true if pLuid matches the users luid or the system luid
|
|
bRet = TRUE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
BOOL
|
|
HangupRasConnections(
|
|
PGLOBALS pGlobals
|
|
)
|
|
{
|
|
DWORD dwError;
|
|
RASCONN rasconn;
|
|
RASCONN* prc;
|
|
DWORD cbSize;
|
|
DWORD cConnections;
|
|
HLOCAL pBuffToFree = NULL;
|
|
|
|
if (!IsRASServiceRunning())
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
prc = &rasconn;
|
|
prc->dwSize = sizeof(RASCONN);
|
|
cbSize = sizeof(RASCONN);
|
|
|
|
dwError = RasEnumConnections(prc, &cbSize, &cConnections);
|
|
|
|
if (dwError == ERROR_BUFFER_TOO_SMALL)
|
|
{
|
|
pBuffToFree = LocalAlloc(LPTR, cbSize);
|
|
|
|
prc = (RASCONN*)pBuffToFree;
|
|
if (prc)
|
|
{
|
|
prc->dwSize = sizeof(RASCONN);
|
|
|
|
dwError = RasEnumConnections(prc, &cbSize, &cConnections);
|
|
}
|
|
}
|
|
|
|
if (dwError == ERROR_SUCCESS)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < cConnections; i++)
|
|
{
|
|
if (IsEqualOrSystemLuid(&prc[i].luid, &pGlobals->LogonId))
|
|
{
|
|
RasHangUp(prc[i].hrasconn);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pBuffToFree)
|
|
{
|
|
LocalFree(pBuffToFree);
|
|
}
|
|
|
|
return (dwError == ERROR_SUCCESS);
|
|
}
|
|
|