windows-nt/Source/XPSP1/NT/net/rras/ras/ui/rassrvui/rassrvui.c

1066 lines
23 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
/*
File rassrvui.c
Entry point implementation for the connections dialup server ui dll.
Paul Mayfield, 9/29/97
Much code was borrowed from stevec's rasdlg.
*/
#include "rassrv.h"
//
// Called to add property pages for the dialup server property sheet
//
DWORD
RasSrvAddPropPage(
IN LPPROPSHEETPAGE lpPage,
IN RASSRV_PAGE_CONTEXT * pPageData)
{
DWORD dwErr = ERROR_UNKNOWN_PROPERTY;
switch(pPageData->dwId)
{
case RASSRVUI_GENERAL_TAB:
dwErr = GenTabGetPropertyPage (lpPage, (LPARAM)pPageData);
break;
case RASSRVUI_USER_TAB:
dwErr = UserTabGetPropertyPage (lpPage, (LPARAM)pPageData);
break;
case RASSRVUI_ADVANCED_TAB:
dwErr = NetTabGetPropertyPage (lpPage, (LPARAM)pPageData);
break;
case RASSRVUI_DEVICE_WIZ_TAB:
dwErr = DeviceWizGetPropertyPage (lpPage, (LPARAM)pPageData);
break;
case RASSRVUI_VPN_WIZ_TAB:
dwErr = VpnWizGetPropertyPage (lpPage, (LPARAM)pPageData);
break;
case RASSRVUI_USER_WIZ_TAB:
dwErr = UserWizGetPropertyPage (lpPage, (LPARAM)pPageData);
break;
case RASSRVUI_PROT_WIZ_TAB:
dwErr = ProtWizGetPropertyPage (lpPage, (LPARAM)pPageData);
break;
case RASSRVUI_DCC_DEVICE_WIZ_TAB:
dwErr = DccdevWizGetPropertyPage (lpPage, (LPARAM)pPageData);
break;
case RASSRVUI_SWITCHMMC_WIZ_TAB:
dwErr = SwitchMmcWizGetProptertyPage (lpPage, (LPARAM)pPageData);
break;
}
return dwErr;
}
//
// Helper function might make code easier to read.
//
DWORD
AddPageHelper (
IN DWORD dwPageId,
IN DWORD dwType,
IN PVOID pvContext,
IN LPFNADDPROPSHEETPAGE pfnAddPage,
IN LPARAM lParam)
{
DWORD dwErr;
HPROPSHEETPAGE hPropPage;
PROPSHEETPAGE PropPage;
RASSRV_PAGE_CONTEXT * pPageCtx = NULL;
// Initialize the page data to send. RassrvMessageFilter will
// clean this stuff up.
pPageCtx = RassrvAlloc(sizeof (RASSRV_PAGE_CONTEXT), TRUE);
if (pPageCtx == NULL)
{
return ERROR_NOT_ENOUGH_MEMORY;
}
pPageCtx->dwId = dwPageId;
pPageCtx->dwType = dwType;
pPageCtx->pvContext = pvContext;
// Create the tab and add it to the property sheet
if ((dwErr = RasSrvAddPropPage(&PropPage, pPageCtx)) != NO_ERROR)
{
return dwErr;
}
if ((hPropPage = CreatePropertySheetPage(&PropPage)) == NULL)
{
return ERROR_CAN_NOT_COMPLETE;
}
if (! (*pfnAddPage)(hPropPage, lParam))
{
return ERROR_CAN_NOT_COMPLETE;
}
return NO_ERROR;
}
//
// Helper function generates a connection name based on the data
// returned from MprApi calls.
//
DWORD
GenerateConnectionName(
IN RAS_CONNECTION_2 * pConn,
OUT PWCHAR pszNameBuffer)
{
NET_API_STATUS nStatus;
USER_INFO_2 * pUserInfo;
DWORD dwFullNameLength;
// Get the full name
nStatus = NetUserGetInfo(
NULL,
pConn->wszUserName,
2,
(LPBYTE*)&pUserInfo);
if (nStatus == NERR_Success)
{
dwFullNameLength = wcslen(pUserInfo->usri2_full_name);
if (dwFullNameLength)
{
wsprintfW(
pszNameBuffer,
L"%s (%s)",
pConn->wszUserName,
pUserInfo->usri2_full_name);
}
else
{
lstrcpynW(
pszNameBuffer,
pConn->wszUserName,
sizeof(pConn->wszUserName) / sizeof(WCHAR));
}
NetApiBufferFree((LPBYTE)pUserInfo);
}
else
{
lstrcpynW(
pszNameBuffer,
pConn->wszUserName,
sizeof(pConn->wszUserName) / sizeof(WCHAR));
}
return NO_ERROR;
}
//
// Generate the connection type and device name
//
DWORD
GenerateConnectionDeviceInfo (
RAS_CONNECTION_2 * pConn,
LPDWORD lpdwType,
PWCHAR pszDeviceName)
{
DWORD dwErr, dwRead, dwTot, dwType, dwClass;
RAS_PORT_0 * pPort = NULL;
RASMAN_INFO Info;
// Initialize the variables
*lpdwType = 0;
*pszDeviceName = (WCHAR)0;
gblConnectToRasServer();
do
{
// Enumerate the ports
//
dwErr = MprAdminPortEnum(
Globals.hRasServer,
0,
pConn->hConnection,
(LPBYTE*)&pPort,
sizeof(RAS_PORT_0) * 2,
&dwRead,
&dwTot,
NULL);
if (dwErr != NO_ERROR)
{
break;
}
if (dwRead == 0)
{
dwErr = ERROR_CAN_NOT_COMPLETE;
break;
}
// Get extended information about the first
// port
//
dwErr = RasGetInfo(NULL, pPort->hPort, &Info);
if (dwErr != NO_ERROR)
{
break;
}
dwClass = RAS_DEVICE_CLASS(Info.RI_rdtDeviceType);
dwType = RAS_DEVICE_TYPE(Info.RI_rdtDeviceType);
lstrcpynW(
pszDeviceName,
pPort[0].wszDeviceName,
MAX_DEVICE_NAME + 1);
if ((dwClass & RDT_Direct) || (dwClass & RDT_Null_Modem))
{
*lpdwType = RASSRVUI_DCC;
}
else if (dwClass & RDT_Tunnel)
{
*lpdwType = RASSRVUI_VPN;
}
else
{
*lpdwType = RASSRVUI_MODEM;
}
} while (FALSE);
// Cleanup
{
if (pPort)
{
MprAdminBufferFree((LPBYTE)pPort);
}
}
return dwErr;
}
//
// Starts the remote access service and marks it as autostart
//
DWORD
RasSrvInitializeService()
{
DWORD dwErr = NO_ERROR, dwTimeout = 60*2;
HANDLE hDialupService, hData = NULL;
BOOL bInitialized = FALSE;
// Get a reference to the service
if ((dwErr = SvcOpenRemoteAccess(&hDialupService)) != NO_ERROR)
{
return dwErr;
}
do
{
RasSrvShowServiceWait(
Globals.hInstDll,
GetActiveWindow(),
&hData);
// First, mark the service as autostart
if ((dwErr = SvcMarkAutoStart(hDialupService)) != NO_ERROR)
{
break;
}
// Start it (with a 5 minute timeout)
dwErr = SvcStart(hDialupService, 60*5);
if (dwErr == ERROR_TIMEOUT)
{
dwErr = ERROR_CAN_NOT_COMPLETE;
break;
}
// Wait for the service to complete initialization
//
while (dwTimeout)
{
bInitialized = MprAdminIsServiceRunning(NULL);
if (bInitialized)
{
break;
}
Sleep(1000);
dwTimeout--;
}
if (dwTimeout == 0)
{
dwErr = ERROR_CAN_NOT_COMPLETE;
break;
}
} while (FALSE);
// Cleanup
//
{
RasSrvFinishServiceWait(hData);
// Cleanup the reference to the dialup service
SvcClose(hDialupService);
}
return dwErr;
}
//
// Stops and marks the remote access service as disabled.
//
DWORD
RasSrvCleanupService()
{
DWORD dwErr = NO_ERROR;
HANDLE hDialupService, hData = NULL;
BOOL fIcRunningBefore = FALSE;
BOOL fIcRunningAfter = FALSE;
RasSrvIsServiceRunning( &fIcRunningBefore );
// Get a reference to the service
if ((dwErr = SvcOpenRemoteAccess(&hDialupService)) != NO_ERROR)
{
return dwErr;
}
do
{
RasSrvShowServiceWait(
Globals.hInstDll,
GetActiveWindow(),
&hData);
// First, stop the service (with a 5 minute timeout)
//
dwErr = SvcStop(hDialupService, 60*5);
if (dwErr == ERROR_TIMEOUT)
{
dwErr = ERROR_CAN_NOT_COMPLETE;
break;
}
if (dwErr != NO_ERROR)
{
break;
}
// Mark it as disabled
if ((dwErr = SvcMarkDisabled(hDialupService)) != NO_ERROR)
{
break;
}
} while (FALSE);
// Cleanup
//
{
RasSrvFinishServiceWait(hData);
SvcClose(hDialupService);
}
//For whistler bug 123769
//If the this connection to be deleted is Incoming connection
//go to disable PortMapping
if ( NO_ERROR == RasSrvIsServiceRunning( &fIcRunningAfter ) )
{
if ( fIcRunningBefore && !fIcRunningAfter )
{
dwErr = HnPMConfigureAllConnections( FALSE );
//this is taken out because we decide not to delete the portmappings,
//just disable them instead. I keep this just for future reference. gangz
//
// if (NO_ERROR == dwErr )
// {
// dwErr = HnPMDeletePortMapping();
// }
}
}
return dwErr;
}
//
// Reports whether the dialup service is running
//
DWORD
APIENTRY
RasSrvIsServiceRunning (
OUT BOOL* pfIsRunning)
{
DWORD dwErr = NO_ERROR;
HANDLE hDialupService = NULL;
// Get a reference to the service
if ((dwErr = SvcOpenRemoteAccess(&hDialupService)) != NO_ERROR)
{
return dwErr;
}
do
{
// Get the current status. SvcIsStarted checks the validity
// of the pfIsRunning parameter.
dwErr = SvcIsStarted(hDialupService, pfIsRunning);
if (dwErr != NO_ERROR)
{
break;
}
} while (FALSE);
// Cleanup
{
// Cleanup the reference to the dialup service
SvcClose(hDialupService);
}
return NO_ERROR;
}
//
// Returns whether the conenctions wizard should be allowed to show.
//
DWORD
APIENTRY
RasSrvAllowConnectionsWizard (
OUT BOOL* pfAllow)
{
DWORD dwErr = NO_ERROR, dwFlags = 0;
if (!pfAllow)
{
return ERROR_INVALID_PARAMETER;
}
// Initialize the product type
if ((dwErr = RasSrvGetMachineFlags (&dwFlags)) != NO_ERROR)
{
return dwErr;
}
// Member or domain servers are not allowed to be shown
if ((dwFlags & RASSRVUI_MACHINE_F_Server) &&
(dwFlags & RASSRVUI_MACHINE_F_Member))
{
*pfAllow = FALSE;
}
else
{
*pfAllow = TRUE;
}
return NO_ERROR;
}
//
// On ntw or standalone nts, returns result of RasSrvIsServiceRunning.
// Otherwise returns false.
//
DWORD
APIENTRY
RasSrvAllowConnectionsConfig (
OUT BOOL* pfAllow)
{
BOOL bAllowWizard;
DWORD dwErr;
if ((dwErr = RasSrvAllowConnectionsWizard (&bAllowWizard)) != NO_ERROR)
{
return dwErr;
}
if (bAllowWizard)
{
return RasSrvIsServiceRunning(pfAllow);
}
*pfAllow = FALSE;
return NO_ERROR;
}
//
// Checks to see if remote access service is installed
//
BOOL
RasSrvIsRemoteAccessInstalled ()
{
const WCHAR pszServiceKey[] =
L"SYSTEM\\CurrentControlSet\\Services\\RemoteAccess";
HKEY hkService = NULL;
DWORD dwErr = NO_ERROR;
// Attempt to open the service registry key
dwErr = RegOpenKeyExW(
HKEY_LOCAL_MACHINE,
pszServiceKey,
0,
KEY_READ | KEY_WRITE,
&hkService);
// If we opened the key ok, then we can assume
// that the service is installed
if (dwErr == ERROR_SUCCESS)
{
RegCloseKey(hkService);
return TRUE;
}
return FALSE;
}
//
// Adds the required tabs to the incoming connections property sheet.
//
DWORD
APIENTRY
RasSrvAddPropPages (
IN HRASSRVCONN hRasSrvConn,
IN HWND hwndParent,
IN LPFNADDPROPSHEETPAGE pfnAddPage,
IN LPARAM lParam,
IN OUT PVOID * ppvContext)
{
DWORD dwErr;
// Check parameters
if (!pfnAddPage || !ppvContext)
{
return ERROR_INVALID_PARAMETER;
}
// Make sure remote access is installed
if (!RasSrvIsRemoteAccessInstalled())
{
return ERROR_SERVICE_DEPENDENCY_FAIL;
}
// Create the context for this page
if ((dwErr = RassrvCreatePageSetCtx(ppvContext)) != NO_ERROR)
{
return dwErr;
}
// Add the tabs
AddPageHelper(RASSRVUI_GENERAL_TAB,
RASWIZ_TYPE_INCOMING,
*ppvContext,
pfnAddPage,
lParam);
AddPageHelper(RASSRVUI_USER_TAB,
RASWIZ_TYPE_INCOMING,
*ppvContext,
pfnAddPage,
lParam);
AddPageHelper(RASSRVUI_ADVANCED_TAB,
RASWIZ_TYPE_INCOMING,
*ppvContext,
pfnAddPage,
lParam);
return NO_ERROR;
}
//
// Adds the required tabs to the incoming connections wizard
//
DWORD
APIENTRY
RasSrvAddWizPages (
IN LPFNADDPROPSHEETPAGE pfnAddPage,
IN LPARAM lParam,
IN OUT PVOID * ppvContext)
{
DWORD dwErr;
BOOL bAllowWizard;
// Check parameters
if (!pfnAddPage || !ppvContext)
{
return ERROR_INVALID_PARAMETER;
}
// Make sure remote access is installed
if (!RasSrvIsRemoteAccessInstalled())
{
return ERROR_SERVICE_DEPENDENCY_FAIL;
}
// Find out if configuration through connections is allowed
dwErr = RasSrvAllowConnectionsWizard (&bAllowWizard);
if (dwErr != NO_ERROR)
{
return dwErr;
}
// Create the context for this page
if ((dwErr = RassrvCreatePageSetCtx(ppvContext)) != NO_ERROR)
{
return dwErr;
}
// If configuration is allowed, add the wizard pages as normal
if (bAllowWizard)
{
// Add the tabs
AddPageHelper(RASSRVUI_DEVICE_WIZ_TAB,
RASWIZ_TYPE_INCOMING,
*ppvContext,
pfnAddPage,
lParam);
AddPageHelper(RASSRVUI_VPN_WIZ_TAB,
RASWIZ_TYPE_INCOMING,
*ppvContext,
pfnAddPage,
lParam);
AddPageHelper(RASSRVUI_USER_WIZ_TAB,
RASWIZ_TYPE_INCOMING,
*ppvContext,
pfnAddPage,
lParam);
AddPageHelper(RASSRVUI_PROT_WIZ_TAB,
RASWIZ_TYPE_INCOMING,
*ppvContext,
pfnAddPage,
lParam);
}
// Otherwise, add the bogus page that
// switches to mmc.
else
{
// Add the tabs
AddPageHelper(RASSRVUI_SWITCHMMC_WIZ_TAB,
RASWIZ_TYPE_INCOMING,
*ppvContext,
pfnAddPage,
lParam);
}
return NO_ERROR;
}
//
// Function adds the host-side direct connect wizard pages
//
DWORD
APIENTRY
RassrvAddDccWizPages(
IN LPFNADDPROPSHEETPAGE pfnAddPage,
IN LPARAM lParam,
IN OUT PVOID * ppvContext)
{
DWORD dwErr;
BOOL bAllowWizard;
// Check parameters
if (!pfnAddPage || !ppvContext)
{
return ERROR_INVALID_PARAMETER;
}
// Make sure remote access is installed
if (!RasSrvIsRemoteAccessInstalled())
{
return ERROR_SERVICE_DEPENDENCY_FAIL;
}
// Find out if configuration through connections is allowed
dwErr = RasSrvAllowConnectionsWizard (&bAllowWizard);
if (dwErr != NO_ERROR)
{
return dwErr;
}
// Create the context for this page
if ((dwErr = RassrvCreatePageSetCtx(ppvContext)) != NO_ERROR)
{
return dwErr;
}
if (bAllowWizard)
{
// Add the tabs
AddPageHelper(RASSRVUI_DCC_DEVICE_WIZ_TAB,
RASWIZ_TYPE_DIRECT,
*ppvContext,
pfnAddPage,
lParam);
AddPageHelper(RASSRVUI_USER_WIZ_TAB,
RASWIZ_TYPE_DIRECT,
*ppvContext,
pfnAddPage,
lParam);
}
// Otherwise, add the bogus page that
// switches to mmc.
else
{
// Add the tabs
AddPageHelper(RASSRVUI_SWITCHMMC_WIZ_TAB,
RASWIZ_TYPE_DIRECT,
*ppvContext,
pfnAddPage,
lParam);
}
return NO_ERROR;
}
//
// Function returns the suggested name for an incoming connection.
//
DWORD
APIENTRY
RassrvGetDefaultConnectionName (
IN OUT PWCHAR pszBuffer,
IN OUT LPDWORD lpdwBufSize)
{
PWCHAR pszName;
DWORD dwLen;
// Load the resource string
pszName = (PWCHAR) PszLoadString(
Globals.hInstDll,
SID_DEFAULT_CONNECTION_NAME);
// Calculate length
dwLen = wcslen(pszName);
if (dwLen > *lpdwBufSize)
{
*lpdwBufSize = dwLen;
return ERROR_INSUFFICIENT_BUFFER;
}
// Return the result
wcscpy(pszBuffer, pszName);
*lpdwBufSize = dwLen;
return NO_ERROR;
}
//
// Function behaves anagolously to the WIN32 function RasEnumConnections
// but for client connections instead of dialout connections.
//
DWORD
RasSrvEnumConnections(
IN LPRASSRVCONN pRasSrvCon,
OUT LPDWORD lpcb,
OUT LPDWORD lpcConnections)
{
DWORD dwErr = NO_ERROR, dwEntriesRead, dwTotal, dwFlags = 0;
DWORD dwPrefMax = 1000000, i, dwSizeNeeded = 0;
RAS_CONNECTION_2 * pConnList;
BOOL bCopy = TRUE;
// Sanity Check
if (!pRasSrvCon || !lpcb || !lpcConnections)
{
return ERROR_INVALID_PARAMETER;
}
//
// We do not allow IC ui for member servers
//
RasSrvGetMachineFlags(&dwFlags);
if ((dwFlags & RASSRVUI_MACHINE_F_Server) &&
(dwFlags & RASSRVUI_MACHINE_F_Member))
{
*lpcb = 0;
*lpcConnections = 0;
return NO_ERROR;
}
//
// Get the MprAdmin handle
//
gblConnectToRasServer();
do
{
// Enumerate the structures
dwErr = MprAdminConnectionEnum (
Globals.hRasServer,
2,
(LPBYTE *)&pConnList,
dwPrefMax,
&dwEntriesRead,
&dwTotal,
NULL);
if (dwErr != NO_ERROR)
{
DbgOutputTrace ("MprAdminEnum failed %x\n", dwErr);
break;
}
// Reuse the dwTotal variable
dwTotal = 0;
dwSizeNeeded = 0;
// Copy over the pertanent information
for (i = 0; i < dwEntriesRead; i++)
{
if (pConnList[i].dwInterfaceType == ROUTER_IF_TYPE_CLIENT)
{
dwSizeNeeded += sizeof (RASSRVCONN);
if (dwSizeNeeded > *lpcb)
{
bCopy = FALSE;
}
if (bCopy)
{
// Connection handle
pRasSrvCon[dwTotal].hRasSrvConn =
pConnList[i].hConnection;
// Name
dwErr = GenerateConnectionName(
&pConnList[i],
pRasSrvCon[dwTotal].szEntryName);
if (dwErr != NO_ERROR)
{
continue;
}
// Type and Device Name
dwErr = GenerateConnectionDeviceInfo(
&pConnList[i],
&(pRasSrvCon[dwTotal].dwType),
pRasSrvCon[dwTotal].szDeviceName);
if (dwErr != NO_ERROR)
{
continue;
}
// Guid
pRasSrvCon[dwTotal].Guid = pConnList[i].guid;
dwTotal++;
}
}
}
*lpcb = dwSizeNeeded;
*lpcConnections = dwTotal;
} while (FALSE);
// Cleanup
{
MprAdminBufferFree((LPBYTE)pConnList);
}
if (!bCopy)
{
dwErr = ERROR_BUFFER_TOO_SMALL;
}
return dwErr;
}
//
// Gets the status of a Ras Server Connection
//
DWORD
APIENTRY
RasSrvIsConnectionConnected (
IN HRASSRVCONN hRasSrvConn,
OUT BOOL* pfConnected)
{
RAS_CONNECTION_2 * pConn;
DWORD dwErr;
// Sanity check the parameters
if (!pfConnected)
{
return ERROR_INVALID_PARAMETER;
}
gblConnectToRasServer();
// Query rasman for the connection information
dwErr = MprAdminConnectionGetInfo(
Globals.hRasServer,
0,
hRasSrvConn,
(LPBYTE*)&pConn);
if (dwErr != NO_ERROR)
{
*pfConnected = FALSE;
}
else
{
*pfConnected = TRUE;
}
if (pfConnected)
{
MprAdminBufferFree((LPBYTE)pConn);
}
return NO_ERROR;
}
//
// Hangs up the given connection
//
DWORD
RasSrvHangupConnection(
IN HRASSRVCONN hRasSrvConn)
{
RAS_PORT_0 * pPorts;
DWORD dwRead, dwTot, dwErr, i, dwRet = NO_ERROR;
gblConnectToRasServer();
// Enumerate all of the ports on this connection
dwErr = MprAdminPortEnum(
Globals.hRasServer,
0,
hRasSrvConn,
(LPBYTE*)&pPorts,
4096,
&dwRead,
&dwTot,
NULL);
if (dwErr != NO_ERROR)
{
return dwErr;
}
// Hang up each of the ports individually
for (i = 0; i < dwRead; i++)
{
dwErr = MprAdminPortDisconnect(
Globals.hRasServer,
pPorts[i].hPort);
if (dwErr != NO_ERROR)
{
dwRet = dwErr;
}
}
MprAdminBufferFree((LPBYTE)pPorts);
return dwRet;
}
//
// Queries whether to show icons in the task bar.
//
DWORD
APIENTRY
RasSrvQueryShowIcon (
OUT BOOL* pfShowIcon)
{
DWORD dwErr = NO_ERROR;
HANDLE hMiscDatabase = NULL;
if (!pfShowIcon)
{
return ERROR_INVALID_PARAMETER;
}
do
{
// Open a copy of the miscellaneous database
dwErr = miscOpenDatabase(&hMiscDatabase);
if (dwErr != NO_ERROR)
{
break;
}
// Return the status
dwErr = miscGetIconEnable(hMiscDatabase, pfShowIcon);
if (dwErr != NO_ERROR)
{
break;
}
} while (FALSE);
// Cleanup
{
if (hMiscDatabase)
{
miscCloseDatabase(hMiscDatabase);
}
}
return dwErr;
}
// ===================================
// ===================================
// Dll entry management
// ===================================
// ===================================
//
// Called when another process attaches to this dll
//
DWORD
RassrvHandleProcessAttach(
IN HINSTANCE hInstDll,
IN LPVOID pReserved)
{
// Initialize global variables
//
return gblInit(hInstDll, &Globals);
}
//
// Called when process detaches from this dll
//
DWORD
RassrvHandleProcessDetach(
IN HINSTANCE hInstDll,
IN LPVOID pReserved)
{
// Cleanup global variables
//
return gblCleanup(&Globals);
}
//
// Called when thread attaches to this dll
//
DWORD
RassrvHandleThreadAttach(
IN HINSTANCE hInstDll,
IN LPVOID pReserved)
{
return NO_ERROR;
}
//
// Called when thread detaches from this dll
//
DWORD
RassrvHandleThreadDetach(
IN HINSTANCE hInstDll,
IN LPVOID pReserved)
{
return NO_ERROR;
}