1066 lines
23 KiB
C
1066 lines
23 KiB
C
/*
|
|
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;
|
|
}
|
|
|