archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/net/rras/ras/rasman/dll/apis.c

5499 lines
120 KiB
Raw Blame History

/*++
Copyright (C) 1992-98 Microsft Corporation. All rights reserved.
Module Name:
apis.c
Abstract:
This file contains all entry points for the RASMAN.DLL of
RAS Manager Component.
Author:
Gurdeep Singh Pall (gurdeep) 06-Jun-1997
Revision History:
Miscellaneous Modifications - raos 31-Dec-1997
--*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <rasman.h>
#include <wanpub.h>
#include <media.h>
#include <stdio.h>
#include <raserror.h>
#include <rasppp.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sechost.h>
#include <winsock.h>
#include "defs.h"
#include "structs.h"
#include <sechost.h>
#include "globals.h"
#include "rasmxs.h"
#include "protos.h"
#include "nouiutil.h"
#include "loaddlls.h"
#include "rpc.h"
#include "process.h"
extern RPC_BINDING_HANDLE g_hBinding;
BOOL g_fRasInitialized = FALSE;
BOOL g_fWinsockInitialized = FALSE;
BOOL g_fRasAutoStarted = FALSE;
DWORD g_dwEventCount = 0;
#define SECS_WaitTimeOut 500
#define NET_SVCS_GROUP "-k netsvcs"
DWORD
DwRasGetHostByName(CHAR *pszHostName, DWORD **pdwAddress, DWORD *pcAddresses);
/*++
Routine Description:
This function is called to check if a port handle
supplied to the the API is valid.
Arguments:
Return Value:
TRUE (if valid)
FALSE
--*/
BOOL
ValidatePortHandle (HPORT porthandle)
{
if ((porthandle >= 0))
{
return TRUE ;
}
return FALSE ;
}
BOOL
ValidateConnectionHandle(HANDLE hConnection)
{
RAS_RPC *pRasRpcConnection = (RAS_RPC *) hConnection;
if( NULL != pRasRpcConnection
&& NULL == pRasRpcConnection->hRpcBinding)
{
return FALSE;
}
return TRUE;
}
BOOL
IsRasmanProcess()
{
CHAR *pszCmdLine = NULL;
BOOL fRet = FALSE;
pszCmdLine = GetCommandLine();
RasmanOutputDebug("IsRasmanProcess: CmdLine=%s\n",
(NULL == pszCmdLine)
? "NULL"
: pszCmdLine);
if( (NULL != pszCmdLine)
&& (strstr(pszCmdLine, NET_SVCS_GROUP)))
{
fRet = TRUE;
}
RasmanOutputDebug("IsRasmanProcess: returning %d\n",
fRet);
return fRet;
}
BOOL
IsKnownDll(WCHAR *pwszCustomDialerName)
{
BOOL fRet = FALSE;
WCHAR *pwszDialerName, *pwsz;
if(NULL == pwszCustomDialerName)
{
goto done;
}
pwsz = pwszCustomDialerName + wcslen(pwszCustomDialerName);
while( (L'\\' != *pwsz)
&& (pwsz != pwszCustomDialerName))
{
pwsz--;
}
if(L'\\' == *pwsz)
{
pwsz++;
}
if(0 == _wcsicmp(pwsz, L"cmdial32.dll"))
{
fRet = TRUE;
}
done:
return fRet;
}
/*++
Routine Description:
Used for detecting processes attaching and detaching
to the DLL.
Arguments:
Return Value:
--*/
BOOL
InitRasmanDLL (HANDLE hInst, DWORD ul_reason_being_called, LPVOID lpReserved)
{
WSADATA wsaData;
switch (ul_reason_being_called)
{
case DLL_PROCESS_ATTACH:
DisableThreadLibraryCalls(hInst);
break ;
case DLL_PROCESS_DETACH:
//
// If this is the rasman process detaching -
// don't do anything, else check if rasman
// service should be stopped and then stop
// it.
//
if (!IsRasmanProcess())
{
DWORD dwAttachedCount;
BOOL fPortsOpen;
//
// Dereference rasman only if Ras was initialized in
// this process
//
if (!g_fRasInitialized)
{
break;
}
#if 0
RasGetAttachedCount (&dwAttachedCount);
SubmitRequest(NULL, REQTYPE_CLOSEPROCESSPORTS);
fPortsOpen = SubmitRequest(NULL, REQTYPE_NUMPORTOPEN);
RasReferenceRasman (FALSE);
if ( !fPortsOpen
&& 1 == dwAttachedCount)
{
WaitForRasmanServiceStop () ;
}
#endif
//
// Disconnect from rasmans
//
if (g_hBinding)
{
DWORD dwErr;
dwErr = RasRpcDisconnect (&g_hBinding);
}
}
else
{
//
// Free rasmans dll if we loaded it i.e when in
// mprouter process
//
if (hInstRasmans)
{
FreeLibrary (hInstRasmans);
}
hInstRasmans = NULL;
}
if(NULL != lpReserved)
{
break;
}
//
// Terminate winsock.
//
if(g_fWinsockInitialized)
{
WSACleanup();
g_fWinsockInitialized = FALSE;
}
break ;
}
return 1;
}
/*++
Routine Description:
Returns the product type and sku
Arguments:
ppt - Address to receive the product type
pps - Address to receive the sku
Return Value:
ERROR_SUCCESS if successful
Registry apis errors
--*/
LONG
GetProductTypeAndSku(
PRODUCT_TYPE *ppt,
PRODUCT_SKU *pps OPTIONAL
)
{
LONG lr = ERROR_SUCCESS;
CHAR szProductType[128] = {0};
CHAR szProductSku[128] = {0};
HKEY hkey = NULL;
DWORD dwsize;
DWORD dwtype;
CHAR *pszProductType = "ProductType";
CHAR *pszProductSku = "ProductSuite";
CHAR *pszProductOptions =
"System\\CurrentControlSet\\Control\\ProductOptions";
CHAR *pszServerNT = "ServerNT";
CHAR *pszWinNT = "WinNT";
CHAR *pszPersonal = "Personal";
//
// default to workstation
//
*ppt = PT_WORKSTATION;
if (pps)
{
*pps = 0;
}
//
// Open the ProductOptions key
//
if (ERROR_SUCCESS != (lr = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
pszProductOptions,
0, KEY_READ,
&hkey)))
{
goto done;
}
//
// Query the product type
//
dwsize = sizeof(szProductType);
if(ERROR_SUCCESS != (lr = RegQueryValueEx(
hkey,
pszProductType,
NULL,
&dwtype,
(LPBYTE) szProductType,
&dwsize)))
{
goto done;
}
if(0 == _stricmp(szProductType,
pszServerNT))
{
*ppt = PT_SERVER;
}
else if(0 == _stricmp(szProductType,
pszWinNT))
{
*ppt = PT_WORKSTATION;
}
//
// Query the product sku as appropriate
//
if (*ppt == PT_WORKSTATION && pps)
{
dwsize = sizeof(szProductSku);
if(ERROR_SUCCESS != (lr = RegQueryValueEx(
hkey,
pszProductSku,
NULL,
&dwtype,
(LPBYTE) szProductSku,
&dwsize)))
{
goto done;
}
if (0 == _stricmp(szProductSku, pszPersonal))
{
*pps = PS_PERSONAL;
}
else
{
*pps = PS_PROFESSIONAL;
}
}
done:
if(hkey)
{
RegCloseKey(hkey);
}
RasmanOutputDebug("GetProductType returning 0x%x\n", lr);
return lr;
}
/*++
Routine Description:
Returns the product type
Arguments:
ppt - Address to receive the product type
Return Value:
ERROR_SUCCESS if successful
Registry apis errors
--*/
LONG
GetProductType(PRODUCT_TYPE *ppt)
{
return GetProductTypeAndSku(ppt, NULL);
}
DWORD
RasStartRasAutoIfRequired()
{
SC_HANDLE schandle = NULL;
SC_HANDLE svchandle = NULL;
SERVICE_STATUS status;
DWORD dwErr = SUCCESS;
BOOL fServiceStarted = FALSE;
BOOL fConsumer = FALSE;
if(g_fRasAutoStarted)
{
RasmanOutputDebug(
"StartRasAuto: RasAuto already started. pid=%d\n", _getpid());
goto done;
}
//
// Check to see if this is a consumer platform
// Return if not.
//
fConsumer = IsConsumerPlatform();
if(! fConsumer)
{
RasmanOutputDebug(
"StartRasAuto: not a consumer platform. pid=%d\n", _getpid());
goto done;
}
else
{
RasmanOutputDebug(
"StartRasAuto: is consumer platform. pid=%d\n", _getpid());
}
if( !(schandle = OpenSCManager(NULL,
NULL,
SC_MANAGER_CONNECT))
|| !(svchandle = OpenService(schandle,
TEXT("RasAuto"),
SERVICE_START |
SERVICE_QUERY_STATUS)))
{
dwErr = GetLastError();
RasmanOutputDebug("StartRasAuto: Failed to open SCM/Service. dwErr=%d\n",
dwErr);
goto done;
}
while (TRUE)
{
//
// Check if service is already starting:
//
if (QueryServiceStatus(svchandle, &status) == FALSE)
{
dwErr = GetLastError();
goto done;
}
RasmanOutputDebug("StartRasAuto: ServiceStatus=%d\n",
status.dwCurrentState);
switch (status.dwCurrentState)
{
case SERVICE_STOPPED:
{
//
// If we had previously tried to start the service
// and failed. Quit
//
if (fServiceStarted)
{
RasmanOutputDebug("StartRasAuto: failed to start rasauto\n");
dwErr = ERROR_RASAUTO_CANNOT_INITIALIZE;
goto done;
}
RasmanOutputDebug("StartRasAuto: Starting RasAuto...\n");
if (StartService (svchandle, 0, NULL) == FALSE)
{
dwErr = GetLastError() ;
RasmanOutputDebug("StartRasAuto: StartService failed. rc=0x%x",
dwErr);
if(ERROR_SERVICE_ALREADY_RUNNING == dwErr)
{
dwErr = SUCCESS;
}
else if(SUCCESS != dwErr)
{
dwErr = ERROR_RASAUTO_CANNOT_INITIALIZE;
goto done;
}
}
fServiceStarted = TRUE;
break;
}
case SERVICE_START_PENDING:
{
Sleep (500L) ;
break ;
}
case SERVICE_RUNNING:
{
g_fRasAutoStarted = TRUE;
goto done;
}
default:
{
dwErr = ERROR_RASAUTO_CANNOT_INITIALIZE;
goto done;
}
}
}
done:
if(NULL != schandle)
{
CloseServiceHandle(schandle);
}
if(NULL != svchandle)
{
CloseServiceHandle(svchandle);
}
RasmanOutputDebug("StartRasAuto: returning 0x%x\n",
dwErr);
return dwErr;
}
DWORD
RasmanUninitialize()
{
DWORD dwRetcode = ERROR_SUCCESS;
if (!IsRasmanProcess())
{
#if 0
DbgPrint("RasmanUninitialize: Uninitializing rasman. pid=%d\n",
GetCurrentProcessId());
#endif
//
// Dereference rasman only if Ras was initialized in
// this process
//
if (!g_fRasInitialized)
{
goto done;
}
RasReferenceRasman (FALSE);
//
// Disconnect from rasmans
//
if (g_hBinding)
{
DWORD dwErr;
dwErr = RasRpcDisconnect (&g_hBinding);
g_hBinding = NULL;
}
}
else
{
//
// Free rasmans dll if we loaded it i.e when in
// mprouter process
//
if (hInstRasmans)
{
FreeLibrary (hInstRasmans);
}
hInstRasmans = NULL;
}
//
// Terminate winsock.
//
if(g_fWinsockInitialized)
{
WSACleanup();
g_fWinsockInitialized = FALSE;
}
g_fRasInitialized = FALSE;
done:
#if 0
DbgPrint("\nRasmanUninitialize: uninitialized rasman\n");
#endif
return dwRetcode;
}
DWORD
RasInitializeNoWait ()
{
hInstRasmans = NULL;
g_fnServiceRequest = NULL;
// GetStartupInfo(&startupinfo) ;
if (IsRasmanProcess())
{
//
// Load rasmans dll and initialize "ServiceRequest"
// fn pointer
//
hInstRasmans = LoadLibrary ("rasmans.dll");
if (NULL == hInstRasmans)
{
RasmanOutputDebug("RasIntializeNoWait: hInstRasmans==NULL!\n");
return ERROR_RASMAN_CANNOT_INITIALIZE;
}
g_fnServiceRequest = GetProcAddress (hInstRasmans,
TEXT("ServiceRequestInProcess"));
if (NULL == g_fnServiceRequest)
{
FreeLibrary (hInstRasmans);
RasmanOutputDebug("RasInitializeNoWait: g_fnServiceRequest==NULL!\n");
return ERROR_RASMAN_CANNOT_INITIALIZE;
}
return SUCCESS;
}
//
// Initialize winsock if we haven't done so already
//
if (!g_fWinsockInitialized)
{
int status = 0;
WSADATA wsaData;
status = WSAStartup(MAKEWORD(2,0), &wsaData);
if(0 != status)
{
return WSAGetLastError();
}
g_fWinsockInitialized = TRUE;
}
return SUCCESS ;
}
/*++
Routine Description:
Called to map the shared space into the attaching process.
Arguments:
Return Value:
SUCCESS
--*/
DWORD
RasInitialize ()
{
SC_HANDLE schandle = NULL;
SC_HANDLE svchandle = NULL;
SERVICE_STATUS status ;
BOOL fRasmanStarted = FALSE;
DWORD dwErr = ERROR_SUCCESS;
dwErr = RasInitializeNoWait ();
if (dwErr)
{
goto done;
}
//
// Get handles to check status of service and
// (if it is not started -) to start it.
//
if ( !(schandle = OpenSCManager(NULL,
NULL,
SC_MANAGER_CONNECT))
|| !(svchandle = OpenService(schandle,
RASMAN_SERVICE_NAME,SERVICE_START
|SERVICE_QUERY_STATUS)))
{
dwErr = GetLastError();
goto done;
}
while (TRUE)
{
//
// Check if service is already starting:
//
if (QueryServiceStatus(svchandle,&status) == FALSE)
{
dwErr = GetLastError();
goto done;
}
switch (status.dwCurrentState)
{
case SERVICE_STOPPED:
//
// If we had previously tried to start rasman
// and failed. Quit
//
if (fRasmanStarted)
{
RasmanOutputDebug("RasInitialize: SERVICE_STOPPED!\n");
dwErr = ERROR_RASMAN_CANNOT_INITIALIZE;
goto done;
}
if (StartService (svchandle, 0, NULL) == FALSE)
{
GlobalError = GetLastError() ;
RasmanOutputDebug("RasInitialize: StartService returned 0x%x\n",
GlobalError);
if(ERROR_SERVICE_ALREADY_RUNNING == GlobalError)
{
GlobalError = SUCCESS;
}
else if(SUCCESS != dwErr)
{
dwErr = ERROR_RASMAN_CANNOT_INITIALIZE;
goto done;
}
}
fRasmanStarted = TRUE;
break;
case SERVICE_START_PENDING:
Sleep (500L) ;
break ;
case SERVICE_RUNNING:
{
BOOL fRasmanProcess = IsRasmanProcess();
//
// This means that local rpc server is already running
// We should be able to connect to it if we haven't
// already
//
if ( !fRasmanProcess
&& (NULL != g_hBinding))
{
goto done;
}
if(!fRasmanProcess)
{
#if 0
DbgPrint("RasInitialize: Initializing rasman. pid %d\n",
GetCurrentProcessId());
#endif
if (dwErr = RasRpcConnect (NULL, &g_hBinding))
{
RasmanOutputDebug ("RasInitialize: Failed to "
"connect to local server. %d\n",
dwErr);
dwErr = ERROR_RASMAN_CANNOT_INITIALIZE;
goto done;
}
}
//
// Reference rasman only if this is not running in
// svchost.exe. Otherwise the service calling
// RasInitialize explicitly references rasman.
// Change this to be done in a more graceful
// way.
//
// GetStartupInfo(&startupinfo) ;
if (!fRasmanProcess)
{
if (dwErr = RasReferenceRasman(TRUE))
{
RasmanOutputDebug("RasInitialize: failed to "
"reference rasman. %d\n",
dwErr );
dwErr = ERROR_RASMAN_CANNOT_INITIALIZE;
goto done;
}
}
g_fRasInitialized = TRUE;
goto done;
}
default:
RasmanOutputDebug("RasInitialize: Invalid service.status=%d\n",
status.dwCurrentState);
dwErr = ERROR_RASMAN_CANNOT_INITIALIZE;
break;
}
}
done:
if(NULL != schandle)
{
CloseServiceHandle(schandle);
}
if(NULL != svchandle)
{
CloseServiceHandle(svchandle);
}
return dwErr ;
}
/*++
Routine Description:
Opens Port for which name is specified.
Arguments:
Return Value:
SUCCESS
ERROR_PORT_ALREADY_OPEN
ERROR_PORT_NOT_FOUND
--*/
DWORD APIENTRY
RasPortOpen ( PCHAR portname,
HPORT* porthandle,
HANDLE notifier)
{
DWORD pid ;
pid = GetCurrentProcessId() ;
return SubmitRequest( NULL,
REQTYPE_PORTOPEN,
portname,
notifier,
pid,
TRUE,
porthandle);
}
DWORD APIENTRY
RasPortOpenEx(CHAR *pszDeviceName,
DWORD dwDeviceLineCounter,
HPORT *phport,
HANDLE hnotifier,
DWORD *pdwUsageFlags)
{
DWORD retcode =
SubmitRequest(NULL,
REQTYPE_PORTOPENEX,
pszDeviceName,
dwDeviceLineCounter,
hnotifier,
TRUE,
pdwUsageFlags,
phport);
//
// If user name is not NULL and password is
// NULL and this is not the svchost process,
// get the user sid and save it in the ports
// user data
//
if( (ERROR_SUCCESS == retcode)
&& (!IsRasmanProcess()))
{
DWORD dwErr;
PWCHAR pszSid = LocalAlloc(LPTR, 5000);
if(NULL != pszSid)
{
dwErr = GetUserSid(pszSid, 5000);
if(ERROR_SUCCESS == dwErr)
{
dwErr = RasSetPortUserData(
*phport,
PORT_USERSID_INDEX,
(PBYTE) pszSid,
5000);
}
LocalFree(pszSid);
}
else
{
RasmanOutputDebug("RASMAN: RasPppStart: failed to allocate sid\n");
}
}
return retcode;
}
/*++
Routine Description:
Opens Port for which name is specified.
Arguments:
Return Value:
SUCCESS
ERROR_PORT_ALREADY_OPEN
ERROR_PORT_NOT_FOUND
--*/
DWORD APIENTRY
RasPortReserve (PCHAR portname, HPORT* porthandle)
{
DWORD pid ;
pid = GetCurrentProcessId() ;
return SubmitRequest( NULL,
REQTYPE_PORTOPEN,
portname,
NULL,
pid,
FALSE,
porthandle) ;
}
/*++
Routine Description:
Opens Port for which name is specified.
Arguments:
Return Value:
SUCCESS
ERROR_PORT_ALREADY_OPEN
ERROR_PORT_NOT_FOUND
--*/
DWORD APIENTRY
RasPortFree (HPORT porthandle)
{
DWORD pid ;
pid = GetCurrentProcessId() ;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_PORTCLOSE,
porthandle,
pid,
FALSE) ;
}
/*++
Routine Description:
Closes the Port for which the handle is specified.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortClose (HPORT porthandle)
{
DWORD pid ;
pid = GetCurrentProcessId() ;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_PORTCLOSE,
porthandle,
pid,
TRUE) ;
}
/*++
Routine Description:
Enumerates all the Ports configured for RAS.
Arguments:
Return Value:
SUCCESS
ERROR_BUFFER_TOO_SMALL
--*/
DWORD APIENTRY
RasPortEnum (HANDLE hConnection,
PBYTE buffer,
PDWORD size,
PDWORD entries)
{
DWORD dwError = SUCCESS;
RAS_RPC *pRasRpcConnection = (RAS_RPC *) hConnection;
PBYTE buffer40 = NULL;
PBYTE buffer32 = NULL;
DWORD dwSize32 = 0;
DWORD dwsize40 = 0;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
//
// If the request is for a remote server and the server
// version is 4.0 - steelhead, then defer to the old way
// of getting this information since rasman has become
// a rpc server only in version 50.
//
if( NULL != pRasRpcConnection
&& VERSION_40 == pRasRpcConnection->dwVersion)
{
//
// Allocate 40 buffer
//
if(buffer != NULL)
{
dwsize40 = sizeof(RASMAN_PORT_400)
* ((*size)/sizeof(RASMAN_PORT));
buffer40 = LocalAlloc(LPTR, dwsize40);
if(NULL == buffer40)
{
dwError = GetLastError();
goto done;
}
}
dwError = RemoteRasPortEnum(hConnection,
buffer40,
&dwsize40,
entries);
if( (ERROR_SUCCESS == dwError)
&& (NULL != buffer))
{
DWORD i;
RASMAN_PORT *pPort = (RASMAN_PORT *) buffer;
RASMAN_PORT_400 *pPort400 = (RASMAN_PORT_400 *) buffer40;
//
// Copy over the information from the 40 buffer
// to 50 buffer
//
for(i = 0; i < *entries; i++)
{
pPort[i].P_Handle = pPort400[i].P_Handle;
strcpy(pPort[i].P_PortName,
pPort400[i].P_PortName);
pPort[i].P_Status = pPort400[i].P_Status;
pPort[i].P_ConfiguredUsage =
pPort400[i].P_ConfiguredUsage;
pPort[i].P_CurrentUsage = pPort400[i].P_CurrentUsage;
strcpy(pPort[i].P_MediaName,
pPort400[i].P_MediaName);
strcpy(pPort[i].P_DeviceType,
pPort400[i].P_DeviceType);
strcpy(pPort[i].P_DeviceName,
pPort400[i].P_DeviceName);
pPort[i].P_LineDeviceId = pPort400[i].P_LineDeviceId;
pPort[i].P_AddressId = pPort400[i].P_AddressId;
if(0 == _stricmp(pPort400[i].P_DeviceType,
"modem"))
{
pPort->P_rdtDeviceType = RDT_Modem;
}
else if(0 == _stricmp(pPort400[i].P_DeviceType,
"isdn"))
{
pPort->P_rdtDeviceType = RDT_Isdn;
}
else if(0 == _stricmp(pPort400[i].P_DeviceType,
"x25"))
{
pPort->P_rdtDeviceType = RDT_X25;
}
else if(0 == _stricmp(pPort400[i].P_DeviceType,
"vpn"))
{
pPort->P_rdtDeviceType = RDT_Tunnel_Pptp | RDT_Tunnel;
}
else
{
pPort->P_rdtDeviceType = RDT_Other;
}
}
}
else if(ERROR_BUFFER_TOO_SMALL == dwError)
{
*size = sizeof(RASMAN_PORT)
* (dwsize40/sizeof(RASMAN_PORT_400));
}
}
else
{
//
// Thunk the ports structure
//
if(NULL == size)
{
dwError = E_INVALIDARG;
goto done;
}
dwSize32 = (*size/sizeof(RASMAN_PORT)) * sizeof(RASMAN_PORT_32);
if(0 != dwSize32)
{
buffer32 = LocalAlloc(LPTR, dwSize32);
if(NULL == buffer32)
{
dwError = E_OUTOFMEMORY;
goto done;
}
}
dwError = SubmitRequest(hConnection,
REQTYPE_PORTENUM,
&dwSize32, //size,
buffer32, //buffer,
entries) ;
if( (dwError != ERROR_SUCCESS)
&& (dwError != ERROR_BUFFER_TOO_SMALL))
{
goto done;
}
if(*size < (dwSize32/sizeof(RASMAN_PORT_32)) * sizeof(RASMAN_PORT))
{
dwError = ERROR_BUFFER_TOO_SMALL;
}
*size = (dwSize32/sizeof(RASMAN_PORT_32)) * sizeof(RASMAN_PORT);
if(ERROR_SUCCESS == dwError)
{
DWORD i;
RASMAN_PORT *pPort;
RASMAN_PORT_32 *pPort32;
#if defined (_WIN64)
//
// Thunk the rasman port structures
//
for(i = 0; i < *entries; i++)
{
pPort = &((RASMAN_PORT *) buffer)[i];
pPort32 = &((RASMAN_PORT_32 *) buffer32 )[i];
//
// Copy handle
//
pPort->P_Handle = UlongToHandle(pPort32->P_Port);
//
// Copy rest of the structure - this should be the
// same for all platforms
//
CopyMemory(
(PBYTE) pPort + FIELD_OFFSET(RASMAN_PORT, P_PortName),
(PBYTE) pPort32 + FIELD_OFFSET(RASMAN_PORT_32, P_PortName),
sizeof(RASMAN_PORT_32) - sizeof(DWORD));
}
#else
if(NULL != buffer32)
CopyMemory(buffer, buffer32, *size);
#endif
}
}
done:
if(NULL != buffer40)
{
LocalFree(buffer40);
}
if(NULL != buffer32)
{
LocalFree(buffer32);
}
return dwError;
}
/*++
Routine Description:
Gets parameters (info) for the Port for which handle
is supplied
Arguments:
Return Value:
SUCCESS
ERROR_BUFFER_TOO_SMALL
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortGetInfo ( HANDLE hConnection,
HPORT porthandle,
PBYTE buffer,
PDWORD size)
{
DWORD dwError = SUCCESS;
RAS_RPC *pRasRpcConnection = (RAS_RPC *) hConnection;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
//
// If the request is for a remote server and the server
// version is 4.0 - steelhead, then defer to the old way
// of getting this information since rasman has become
// a rpc server only in version 50.
//
if( NULL != pRasRpcConnection
&& VERSION_40 == pRasRpcConnection->dwVersion)
{
dwError = RemoteRasPortGetInfo(hConnection,
porthandle,
buffer,
size);
}
else
{
dwError = SubmitRequest(hConnection,
REQTYPE_PORTGETINFO,
porthandle,
buffer,
size);
}
done:
return dwError;
}
/*++
Routine Description:
Sets parameters (info) for the Port for which handle
is supplied
Arguments:
Return Value:
SUCCESS
ERROR_CANNOT_SET_PORT_INFO
ERROR_WRONG_INFO_SPECIFIED
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortSetInfo (HPORT porthandle,
RASMAN_PORTINFO* info)
{
DWORD size=info->PI_NumOfParams*sizeof(RAS_PARAMS) ;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_PORTSETINFO,
porthandle,
info) ;
}
/*++
Routine Description:
Disconnects the port for which handle is supplied.
Arguments:
Return Value:
PENDING
ERROR_NOT_CONNECTED
ERROR_EVENT_INVALID
ERROR_INVALID_PORT_HANDLE
anything GetLastError returns from CreateEvent calls
--*/
DWORD APIENTRY
RasPortDisconnect (HPORT porthandle,
HANDLE winevent)
{
DWORD pid ;
HANDLE hEvent;
DWORD dwError;
BOOL fCreateEvent = FALSE;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE ;
goto done;
}
fCreateEvent = !!(INVALID_HANDLE_VALUE == winevent);
if (fCreateEvent)
{
hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (NULL == hEvent)
{
fCreateEvent = FALSE;
dwError = GetLastError();
goto done;
}
}
else
{
hEvent = winevent;
}
pid = GetCurrentProcessId () ;
dwError = SubmitRequest( NULL,
REQTYPE_PORTDISCONNECT,
porthandle,
hEvent,
pid);
if ( fCreateEvent
&& PENDING == dwError)
{
//
// Wait till the pending operation
// is done. We are making this call synchronous.
//
WaitForSingleObject(hEvent, INFINITE);
//
//clear the pending error
//
dwError = SUCCESS;
}
if (ERROR_ALREADY_DISCONNECTING == dwError)
{
//
// hit the rare case where there is already
// a disconnect pending on this port and the
// event handle was thrown away. Sleep for
// 5s. before proceeding. The actual disconnect
// should have happened by then. The disconnect
// timeout is 10s in rasman.
//
Sleep(5000);
dwError = ERROR_SUCCESS;
}
done:
if (fCreateEvent)
{
CloseHandle(hEvent);
}
return dwError;
}
/*++
Routine Description:
Sends supplied buffer. If connected writes to RASHUB.
Else it writes to the port directly.
Arguments:
Return Value:
SUCCESS
ERROR_BUFFER_INVALID
ERROR_EVENT_INVALID
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortSend ( HPORT porthandle,
PBYTE buffer,
DWORD size)
{
NDISWAN_IO_PACKET *pPacket;
SendRcvBuffer *pSendRcvBuffer;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
//
// Get Pointer to ndiswan io data
//
pPacket = CONTAINING_RECORD (buffer, NDISWAN_IO_PACKET, PacketData);
//
// Get Pointer to SendRcvBuffer
//
pSendRcvBuffer = CONTAINING_RECORD (pPacket, SendRcvBuffer, SRB_Packet);
return SubmitRequest( NULL,
REQTYPE_PORTSEND,
porthandle,
pSendRcvBuffer,
size );
}
/*++
Routine Description:
Receives in supplied buffer. If connected reads through
RASHUB. Else, it writes to the port directly.
Arguments:
Return Value:
PENDING
ERROR_BUFFER_INVALID
ERROR_EVENT_INVALID
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortReceive ( HPORT porthandle,
PBYTE buffer,
PDWORD size,
DWORD timeout,
HANDLE winevent)
{
DWORD pid ;
NDISWAN_IO_PACKET *pPacket;
SendRcvBuffer *pSendRcvBuffer;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
pid = GetCurrentProcessId () ;
//
// Get Pointer to ndiswan io data
//
pPacket = CONTAINING_RECORD ( buffer, NDISWAN_IO_PACKET, PacketData );
//
// Get Pointer to SendRcvBuffer
//
pSendRcvBuffer = CONTAINING_RECORD ( pPacket, SendRcvBuffer, SRB_Packet );
return SubmitRequest ( NULL,
REQTYPE_PORTRECEIVE,
porthandle,
pSendRcvBuffer,
size,
timeout,
winevent,
pid) ;
}
DWORD APIENTRY
RasPortReceiveEx ( HPORT porthandle,
PBYTE buffer,
PDWORD size )
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE;
}
return SubmitRequest ( NULL,
REQTYPE_PORTRECEIVEEX,
porthandle,
buffer,
size);
}
/*++
Routine Description:
Cancels a previously pending receive
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortCancelReceive (HPORT porthandle)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest (NULL,
REQTYPE_CANCELRECEIVE,
porthandle) ;
}
/*++
Routine Description:
Posts a listen on the device connected to the port.
Arguments:
Return Value:
PENDING
ERROR_EVENT_INVALID
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortListen( HPORT porthandle,
ULONG timeout,
HANDLE winevent)
{
DWORD pid ;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
pid = GetCurrentProcessId () ;
return SubmitRequest ( NULL,
REQTYPE_PORTLISTEN,
porthandle,
timeout,
winevent,
pid) ;
}
/*++
Routine Description:
Changes state of port to CONNECTED and does other
necessary switching.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortConnectComplete (HPORT porthandle)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_PORTCONNECTCOMPLETE,
porthandle) ;
}
/*++
Routine Description:
Fetches statistics for the port for which the handle
is supplied
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasPortGetStatistics ( HANDLE hConnection,
HPORT porthandle,
PBYTE statbuffer,
PDWORD size)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
dwError = SubmitRequest ( hConnection,
REQTYPE_PORTGETSTATISTICS,
porthandle,
statbuffer,
size) ;
done:
return dwError;
}
/*++
Routine Description:
Fetches statistics for the bundle for which the handle
is supplied
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasBundleGetStatistics ( HANDLE hConnection,
HPORT porthandle,
PBYTE statbuffer,
PDWORD size)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest (hConnection,
REQTYPE_BUNDLEGETSTATISTICS,
porthandle,
statbuffer,
size) ;
done:
return dwError;
}
DWORD APIENTRY
RasPortGetStatisticsEx ( HANDLE hConnection,
HPORT porthandle,
PBYTE statBuffer,
PDWORD size)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest(hConnection,
REQTYPE_PORTGETSTATISTICSEX,
porthandle,
statBuffer,
size);
done:
return dwError;
}
DWORD APIENTRY
RasBundleGetStatisticsEx ( HANDLE hConnection,
HPORT portHandle,
PBYTE statbuffer,
PDWORD size)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (portHandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest ( hConnection,
REQTYPE_BUNDLEGETSTATISTICSEX,
portHandle,
statbuffer,
size);
done:
return dwError;
}
/*++
Routine Description:
Clears statistics for the port for which the handle
is supplied
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY RasPortClearStatistics (HANDLE hConnection,
HPORT porthandle)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest ( hConnection,
REQTYPE_PORTCLEARSTATISTICS,
porthandle) ;
done:
return dwError;
}
/*++
Routine Description:
Clears statistics for the bundle for which the
handle is supplied
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY RasBundleClearStatistics(HANDLE hConnection,
HPORT porthandle)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest ( hConnection,
REQTYPE_BUNDLECLEARSTATISTICS,
porthandle) ;
done:
return dwError;
}
DWORD APIENTRY RasBundleClearStatisticsEx(HANDLE hConnection,
HCONN hconn)
{
DWORD dwErr;
HPORT hPort;
dwErr = RasBundleGetPort(hConnection,
(HBUNDLE) hconn,
&hPort);
if (dwErr)
{
goto done;
}
dwErr = SubmitRequest ( hConnection,
REQTYPE_BUNDLECLEARSTATISTICS,
hPort);
done:
return dwErr;
}
/*++
Routine Description:
Enumerates all the devices of a device type.
Arguments:
Return Value:
SUCCESS
ERROR_DEVICE_DOES_NOT_EXIST
ERROR_BUFFER_TOO_SMALL
--*/
DWORD APIENTRY
RasDeviceEnum (HANDLE hConnection,
PCHAR devicetype,
PBYTE buffer,
PDWORD size,
PDWORD entries)
{
DWORD dwError = SUCCESS;
RAS_RPC *pRasRpcConnection = (RAS_RPC *) hConnection;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
//
// If the request is for a remote server and the server
// version is 4.0 - steelhead, then defer to the old way
// of getting this information since rasman has become
// a rpc server only in version 50.
//
if( pRasRpcConnection
&& VERSION_40 == pRasRpcConnection->dwVersion)
{
dwError = RemoteRasDeviceEnum(hConnection,
devicetype,
buffer,
size,
entries);
}
else
{
dwError = SubmitRequest ( hConnection,
REQTYPE_DEVICEENUM,
devicetype,
size,
buffer,
entries
);
}
done:
return dwError;
}
/*++
Routine Description:
Gets info for the specified device.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
ERROR_DEVICETYPE_DOES_NOT_EXIST
ERROR_DEVICE_DOES_NOT_EXIST
ERROR_BUFFER_TOO_SMALL
--*/
DWORD APIENTRY
RasDeviceGetInfo ( HANDLE hConnection,
HPORT porthandle,
PCHAR devicetype,
PCHAR devicename,
PBYTE buffer,
PDWORD size)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest ( hConnection,
REQTYPE_DEVICEGETINFO,
porthandle,
devicetype,
devicename,
buffer,
size) ;
done:
return dwError;
}
/*++
Routine Description:
Sets info for the specified device.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
ERROR_DEVICETYPE_DOES_NOT_EXIST
ERROR_DEVICE_DOES_NOT_EXIST
ERROR_INVALID_INFO_SPECIFIED
--*/
DWORD APIENTRY
RasDeviceSetInfo (HPORT porthandle,
PCHAR devicetype,
PCHAR devicename,
RASMAN_DEVICEINFO* info)
{
DWORD i,
dwOldIndex,
dwcbOldString = 0,
retcode;
PCHAR szOldString = NULL;
BOOL fVpn = FALSE;
RASMAN_INFO ri;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
retcode = RasGetInfo(NULL,
porthandle,
&ri);
if(ERROR_SUCCESS == retcode)
{
if(0 == _stricmp(ri.RI_szDeviceType,
"vpn"))
{
fVpn = TRUE;
}
}
if (fVpn)
{
for (i = 0; i < info->DI_NumOfParams; i++)
{
//
// We're only looking for the
// MXS_PHONENUMBER_KEY key.
//
if ( info->DI_Params[i].P_Type != String
|| _stricmp(info->DI_Params[i].P_Key,
MXS_PHONENUMBER_KEY))
{
continue;
}
//
// We found it. If the phone number is a
// DNS address, convert it to an IP address.
//
if (inet_addr(info->DI_Params[i].P_Value.String.Data)
== -1L)
{
struct hostent *hostp;
DWORD dwErr;
DWORD *pdwAddress;
DWORD cAddresses;
DWORD dwAddress;
dwErr = DwRasGetHostByName(
info->DI_Params[i].P_Value.String.Data,
&pdwAddress,
&cAddresses);
//
// If gethostbyname() succeeds, then replace
// the DNS address with the IP address.
//
/*
hostp = gethostbyname(
info->DI_Params[i].P_Value.String.Data
);
*/
if ( (SUCCESS == dwErr)
&& (0 != cAddresses)
&& (0 != (dwAddress = *pdwAddress)))
{
struct in_addr in;
in.s_addr = dwAddress;
//
// We save the old string value away,
// and set the new value. The old
// value will be restored after the
// call to SubmitRequest(). This works
// because SubmitRequest() has to copy
// the user's params anyway.
//
szOldString =
info->DI_Params[i].P_Value.String.Data;
dwcbOldString =
info->DI_Params[i].P_Value.String.Length;
info->DI_Params[i].P_Value.String.Data =
inet_ntoa(in);
info->DI_Params[i].P_Value.String.Length =
strlen(info->DI_Params[i].P_Value.String.Data);
dwOldIndex = i;
}
if(NULL != pdwAddress)
{
LocalFree(pdwAddress);
}
}
}
}
retcode = SubmitRequest ( NULL,
REQTYPE_DEVICESETINFO,
porthandle,
devicetype,
devicename,
info) ;
if (dwcbOldString)
{
info->DI_Params[dwOldIndex].P_Value.String.Data =
szOldString;
info->DI_Params[dwOldIndex].P_Value.String.Length =
dwcbOldString;
}
return retcode;
}
/*++
Routine Description:
Connects through the device specified.
Arguments:
Return Value:
PENDING
ERROR_INVALID_PORT_HANDLE
ERROR_DEVICETYPE_DOES_NOT_EXIST
ERROR_DEVICE_DOES_NOT_EXIST
ERROR_INVALID_INFO_SPECIFIED
--*/
DWORD APIENTRY
RasDeviceConnect ( HPORT porthandle,
PCHAR devicetype,
PCHAR devicename,
ULONG timeout,
HANDLE winevent)
{
DWORD pid ;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
pid = GetCurrentProcessId () ;
return SubmitRequest ( NULL,
REQTYPE_DEVICECONNECT,
porthandle,
devicetype,
devicename,
timeout,
winevent,
pid) ;
}
/*++
Routine Description:
Gets general info for the port for which handle is
supplied.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasGetInfo (HANDLE hConnection,
HPORT porthandle,
RASMAN_INFO* info)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest ( hConnection,
REQTYPE_GETINFO,
porthandle,
info) ;
done:
return dwError;
}
/*++
Routine Description:
Gets general info for all the ports.
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasGetInfoEx (HANDLE hConnection,
RASMAN_INFO* info,
PWORD entries)
{
return ERROR_NOT_SUPPORTED;
#if 0
DWORD dwError = SUCCESS;
if (info == NULL)
{
dwError = ERROR_BUFFER_TOO_SMALL;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest (hConnection,
REQTYPE_GETINFOEX,
info) ;
done:
return dwError;
#endif
}
/*++
Routine Description:
Gets a buffer to be used with send and receive.
Arguments:
Return Value:
SUCCESS
ERROR_OUT_OF_BUFFERS
--*/
DWORD APIENTRY
RasGetBuffer (PBYTE* buffer, PDWORD size)
{
HANDLE handle = NULL;
DWORD retcode = SUCCESS;
SendRcvBuffer *pSendRcvBuffer = NULL;
//
// Alloc a buffer
//
pSendRcvBuffer = LocalAlloc (LPTR,
sizeof (SendRcvBuffer));
if (NULL == pSendRcvBuffer)
{
retcode = GetLastError();
RasmanOutputDebug ("RASMAN: RasGetBuffer Failed to "
"allocate. %d\n",
retcode);
goto done;
}
pSendRcvBuffer->SRB_Pid = GetCurrentProcessId();
*size = (*size < MAX_SENDRCVBUFFER_SIZE)
? *size
: MAX_SENDRCVBUFFER_SIZE;
*buffer = pSendRcvBuffer->SRB_Packet.PacketData;
done:
return retcode ;
}
/*++
Routine Description:
Frees a buffer gotten earlier with RasGetBuffer()
Arguments:
Return Value:
SUCCESS
ERROR_BUFFER_INVALID
--*/
DWORD APIENTRY
RasFreeBuffer (PBYTE buffer)
{
HANDLE handle;
DWORD retcode = SUCCESS;
SendRcvBuffer *pSendRcvBuffer;
NDISWAN_IO_PACKET *pPacket;
//
// Get Pointer to ndiswan io data
//
pPacket = CONTAINING_RECORD(buffer, NDISWAN_IO_PACKET, PacketData);
//
// Get Pointer to SendRcvBuffer
//
pSendRcvBuffer = CONTAINING_RECORD(pPacket, SendRcvBuffer, SRB_Packet);
LocalFree (pSendRcvBuffer);
return retcode ;
}
/*++
Routine Description:
Retrieves information about protocols configured
in the system.
Arguments:
Return Value:
SUCCESS
ERROR_BUFFER_TOO_SMALL
--*/
DWORD APIENTRY
RasProtocolEnum ( PBYTE buffer,
PDWORD size,
PDWORD entries)
{
return SubmitRequest ( NULL,
REQTYPE_PROTOCOLENUM,
size,
buffer,
entries) ;
}
/*++
Routine Description:
Allocates a route (binding) without actually activating it.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
ERROR_ROUTE_NOT_AVAILABLE
--*/
DWORD APIENTRY
RasAllocateRoute ( HPORT porthandle,
RAS_PROTOCOLTYPE type,
BOOL wrknet,
RASMAN_ROUTEINFO* info)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
//
// Even though this can be done by this process - we pass
// this on to the requestor thread since we get the
// serialization for free.
//
return SubmitRequest ( NULL,
REQTYPE_ALLOCATEROUTE,
porthandle,
type,
wrknet,
info) ;
}
/*++
Routine Description:
Activates a previously allocated route (binding).
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
ERROR_ROUTE_NOT_AVAILABLE
--*/
DWORD APIENTRY
RasActivateRoute ( HPORT porthandle,
RAS_PROTOCOLTYPE type,
RASMAN_ROUTEINFO* info,
PROTOCOL_CONFIG_INFO *config)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_ACTIVATEROUTE,
porthandle,
type,
config,
info) ;
}
/*++
Routine Description:
Activates a previously allocated route (binding).
Allows you to set the max frame size as well
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
ERROR_ROUTE_NOT_AVAILABLE
--*/
DWORD APIENTRY
RasActivateRouteEx ( HPORT porthandle,
RAS_PROTOCOLTYPE type,
DWORD framesize,
RASMAN_ROUTEINFO* info,
PROTOCOL_CONFIG_INFO *config)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_ACTIVATEROUTEEX,
porthandle,
type,
framesize,
config,
info) ;
}
/*++
Routine Description:
DeAllocates a route (binding) that was previously
activated.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
ERROR_ROUTE_NOT_ALLOCATED
--*/
DWORD APIENTRY
RasDeAllocateRoute ( HBUNDLE hbundle,
RAS_PROTOCOLTYPE type)
{
return SubmitRequest ( NULL,
REQTYPE_DEALLOCATEROUTE,
hbundle,
type) ;
}
/*++
Routine Description:
Gets compression information for the port.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasCompressionGetInfo ( HPORT porthandle,
RAS_COMPRESSION_INFO *send,
RAS_COMPRESSION_INFO *recv)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_COMPRESSIONGETINFO,
porthandle,
send,
recv ) ;
}
/*++
Routine Description:
Sets compression information for the port.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
ERROR_INVALID_COMPRESSION_SPECIFIED
--*/
DWORD APIENTRY
RasCompressionSetInfo ( HPORT porthandle,
RAS_COMPRESSION_INFO *send,
RAS_COMPRESSION_INFO *recv)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest( NULL,
REQTYPE_COMPRESSIONSETINFO,
porthandle,
send,
recv) ;
}
/*++
Routine Description:
Gets user credentials (username, password) from LSA.
Arguments:
Return Value:
SUCCESS
Non zero (failure)
--*/
DWORD APIENTRY
RasGetUserCredentials(
PBYTE pChallenge,
PLUID LogonId,
PWCHAR UserName,
PBYTE CaseSensitiveChallengeResponse,
PBYTE CaseInsensitiveChallengeResponse,
PBYTE LMSessionKey,
PBYTE UserSessionKey
)
{
return SubmitRequest (
NULL,
REQTYPE_GETUSERCREDENTIALS,
pChallenge,
LogonId,
UserName,
CaseSensitiveChallengeResponse,
CaseInsensitiveChallengeResponse,
LMSessionKey,
UserSessionKey) ;
}
/*++
Routine Description:
Changes user's cached credentials with LSA.
Arguments:
Return Value:
SUCCESS
Non zero (failure)
--*/
DWORD APIENTRY
RasSetCachedCredentials(
PCHAR Account,
PCHAR Domain,
PCHAR NewPassword )
{
return
SubmitRequest(
NULL,
REQTYPE_SETCACHEDCREDENTIALS,
Account,
Domain,
NewPassword );
}
/*++
Routine Description:
A request event is assocaited with a port for signalling
Arguments:
Return Value:
SUCCESS
ERROR_EVENT_INVALID
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasRequestNotification (HPORT porthandle, HANDLE winevent)
{
DWORD pid ;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
pid = GetCurrentProcessId () ;
return SubmitRequest ( NULL,
REQTYPE_REQUESTNOTIFICATION,
porthandle,
winevent,
pid) ;
}
/*++
Routine Description:
Gets the lan nets lana numbers read from the
registry by Rasman
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasEnumLanNets ( DWORD *count,
UCHAR* lanas)
{
return SubmitRequest ( NULL,
REQTYPE_ENUMLANNETS,
count,
lanas) ;
}
/*++
Routine Description:
Gets the lan nets lana numbers read from the
registry by Rasman
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasPortEnumProtocols ( HANDLE hConnection,
HPORT porthandle,
RAS_PROTOCOLS* protocols,
PDWORD count)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest (hConnection,
REQTYPE_PORTENUMPROTOCOLS,
porthandle,
protocols,
count) ;
done:
return dwError;
}
/*++
Routine Description:
Sets the framing type once the port is connected
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasPortSetFraming ( HPORT porthandle,
RAS_FRAMING type,
RASMAN_PPPFEATURES *Send,
RASMAN_PPPFEATURES *Recv)
{
DWORD sendfeatures = 0 ;
DWORD recvfeatures = 0 ;
DWORD sendbits = 0 ;
DWORD recvbits = 0 ;
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
if (type == PPP)
{
sendfeatures = PPP_FRAMING ;
if (Send)
{
sendfeatures |= (Send->ACFC
? PPP_COMPRESS_ADDRESS_CONTROL
: 0) ;
sendbits = Send->ACCM ;
}
recvfeatures = PPP_FRAMING ;
if (Recv)
{
recvfeatures |= (Recv->ACFC
? PPP_COMPRESS_ADDRESS_CONTROL
: 0) ;
recvbits = Recv->ACCM ;
}
}
else if (type == SLIP)
{
sendfeatures = recvfeatures = SLIP_FRAMING ;
}
else if (type == SLIPCOMP)
{
sendfeatures = recvfeatures = SLIP_FRAMING
| SLIP_VJ_COMPRESSION ;
}
else if (type == SLIPCOMPAUTO)
{
sendfeatures = recvfeatures = SLIP_FRAMING
| SLIP_VJ_AUTODETECT ;
}
else if (type == RAS)
{
sendfeatures = recvfeatures = OLD_RAS_FRAMING ;
}
else if (type == AUTODETECT)
{
}
return SubmitRequest ( NULL,
REQTYPE_SETFRAMING,
porthandle,
sendfeatures,
recvfeatures,
sendbits,
recvbits) ;
}
DWORD APIENTRY
RasPortStoreUserData ( HPORT porthandle,
PBYTE data,
DWORD size)
{
if (ValidatePortHandle (porthandle) == FALSE)
return ERROR_INVALID_PORT_HANDLE ;
return SubmitRequest ( NULL,
REQTYPE_STOREUSERDATA,
porthandle,
data,
size) ;
}
DWORD APIENTRY
RasPortRetrieveUserData ( HPORT porthandle,
PBYTE data,
DWORD *size)
{
if (ValidatePortHandle (porthandle) == FALSE)
return ERROR_INVALID_PORT_HANDLE ;
return SubmitRequest ( NULL,
REQTYPE_RETRIEVEUSERDATA,
porthandle,
data,
size) ;
}
/*++
Routine Description:
A generic scheme for apps to attach disconnect
action that must be performed when the link drops.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
ERROR_PORT_NOT_OPEN
--*/
DWORD APIENTRY
RasPortRegisterSlip (HPORT porthandle,
DWORD ipaddr,
DWORD dwFrameSize,
BOOL priority,
WCHAR *pszDNSAddress,
WCHAR *pszDNS2Address,
WCHAR *pszWINSAddress,
WCHAR *pszWINS2Address)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest (NULL,
REQTYPE_REGISTERSLIP,
porthandle,
ipaddr,
dwFrameSize,
priority,
pszDNSAddress,
pszDNS2Address,
pszWINSAddress,
pszWINS2Address);
}
/*++
Routine Description:
Sets the framing info once the port is connected
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasPortSetFramingEx ( HPORT porthandle,
RAS_FRAMING_INFO *info)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_SETFRAMINGEX,
porthandle,
info) ;
}
/*++
Routine Description:
Gets the framing info once the port is connected
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasPortGetFramingEx ( HANDLE hConnection,
HPORT porthandle,
RAS_FRAMING_INFO *info)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (porthandle) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest ( hConnection,
REQTYPE_GETFRAMINGEX,
porthandle,
info) ;
done:
return dwError;
}
/*++
Routine Description:
Gets the protocol compression attributes for the port
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasPortGetProtocolCompression (HPORT porthandle,
RAS_PROTOCOLTYPE type,
RAS_PROTOCOLCOMPRESSION *send,
RAS_PROTOCOLCOMPRESSION *recv)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest (NULL,
REQTYPE_GETPROTOCOLCOMPRESSION,
porthandle,
type,
send,
recv) ;
}
/*++
Routine Description:
Gets the protocol compression attributes for the port
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasPortSetProtocolCompression (HPORT porthandle,
RAS_PROTOCOLTYPE type,
RAS_PROTOCOLCOMPRESSION *send,
RAS_PROTOCOLCOMPRESSION *recv)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest (NULL,
REQTYPE_SETPROTOCOLCOMPRESSION,
porthandle,
type,
send,
recv) ;
}
/*++
Routine Description:
Gets the framing capabilities for the
port from the mac
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasGetFramingCapabilities ( HPORT porthandle,
RAS_FRAMING_CAPABILITIES* caps)
{
if (ValidatePortHandle (porthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_GETFRAMINGCAPABILITIES,
porthandle,
caps) ;
}
/*++
Routine Description:
Exported call for third party security send
Arguments:
Return Value:
returns from RasPortSend.
--*/
DWORD APIENTRY
RasSecurityDialogSend(
IN HPORT hPort,
IN PBYTE pBuffer,
IN WORD BufferLength
)
{
RASMAN_INFO RasInfo;
DWORD dwRetCode = RasGetInfo( NULL, hPort, &RasInfo );
if ( RasInfo.RI_ConnState != LISTENCOMPLETED )
{
return( ERROR_PORT_DISCONNECTED );
}
return( RasPortSend( hPort, pBuffer, ( DWORD ) BufferLength ) );
}
/*++
Routine Description:
Exported call for third party security send
Arguments:
Return Value:
returns from RasPortSend.
--*/
DWORD APIENTRY
RasSecurityDialogReceive(
IN HPORT hPort,
IN PBYTE pBuffer,
IN PWORD pBufferLength,
IN DWORD Timeout,
IN HANDLE hEvent
)
{
RASMAN_INFO RasInfo;
DWORD dwRetCode = RasGetInfo( NULL, hPort, &RasInfo );
DWORD dwBufLength;
if(ERROR_SUCCESS != dwRetCode)
{
return dwRetCode;
}
if ( RasInfo.RI_ConnState != LISTENCOMPLETED )
{
return( ERROR_PORT_DISCONNECTED );
}
if(NULL == pBufferLength)
{
return E_INVALIDARG;
}
dwBufLength = ( DWORD ) *pBufferLength;
dwRetCode = RasPortReceive( hPort,
pBuffer,
&dwBufLength,
Timeout,
hEvent );
*pBufferLength = (WORD) dwBufLength;
return dwRetCode;
}
/*++
Routine Description:
Gets parameters (info) for the
Port for which handle is supplied
Arguments:
Return Value:
returns from RasPortGetInfo
--*/
DWORD APIENTRY
RasSecurityDialogGetInfo(
IN HPORT hPort,
IN RAS_SECURITY_INFO* pBuffer
)
{
RASMAN_INFO RasInfo;
DWORD dwRetCode = RasGetInfo( NULL, hPort, &RasInfo );
if ( dwRetCode != NO_ERROR )
{
return( dwRetCode );
}
memcpy( pBuffer->DeviceName,
RasInfo.RI_DeviceConnecting,
DEVICE_NAME_LEN + 1);
pBuffer->BytesReceived = RasInfo.RI_BytesReceived;
pBuffer->LastError = RasInfo.RI_LastError;
return( NO_ERROR );
}
/*++
Routine Description:
Sets second HPORT to be multilinked
(bundled) with the first HPORT
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasPortBundle (HPORT firstporthandle, HPORT secondporthandle)
{
if (ValidatePortHandle (firstporthandle) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
if (ValidatePortHandle (secondporthandle) == FALSE)
return ERROR_INVALID_PORT_HANDLE ;
return SubmitRequest ( NULL,
REQTYPE_PORTBUNDLE,
firstporthandle,
secondporthandle) ;
}
/*++
Routine Description:
Given a port this API returns a connected
port handle from the same bundle this port
is or was (if not connected) part of.
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasPortGetBundledPort (HPORT oldport, HPORT *pnewport)
{
if (ValidatePortHandle (oldport) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest (NULL,
REQTYPE_GETBUNDLEDPORT,
oldport,
pnewport) ;
}
/*++
Routine Description:
Given a port this API returns handle to a bundle
Arguments:
Return Value:
SUCCESS
ERROR_PORT_DISCONNECTED
--*/
DWORD APIENTRY
RasPortGetBundle (HANDLE hConnection,
HPORT hport,
HBUNDLE *phbundle)
{
DWORD dwError = SUCCESS;
if (ValidatePortHandle (hport) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest (hConnection,
REQTYPE_PORTGETBUNDLE,
hport,
phbundle) ;
done:
return dwError;
}
/*++
Routine Description:
Given a bundle this API returns a connected
port handle part of the bundle.
Arguments:
Return Value:
SUCCESS
ERROR_INVALID_PORT_HANDLE
--*/
DWORD APIENTRY
RasBundleGetPort (HANDLE hConnection,
HBUNDLE hbundle,
HPORT *phport)
{
DWORD dwError = SUCCESS;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest (hConnection,
REQTYPE_BUNDLEGETPORT,
hbundle,
phport) ;
done:
return dwError;
}
/*++
Routine Description:
Increment/decrement the shared buffer attach count for
use with other services inside the rasman.exe process.
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasReferenceRasman (BOOL fAttach)
{
return SubmitRequest (NULL,
REQTYPE_SETATTACHCOUNT,
fAttach);
}
/*++
Routine Description:
Retrieve the stored dial parameters for an entry UID.
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasGetDialParams(
DWORD dwUID,
LPDWORD pdwMask,
PRAS_DIALPARAMS pDialParams
)
{
return SubmitRequest ( NULL,
REQTYPE_GETDIALPARAMS,
dwUID,
pdwMask,
pDialParams);
}
/*++
Routine Description:
Store new dial parameters for an entry UID.
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasSetDialParams(
DWORD dwUID,
DWORD dwMask,
PRAS_DIALPARAMS pDialParams,
BOOL fDelete
)
{
return SubmitRequest ( NULL,
REQTYPE_SETDIALPARAMS,
dwUID,
dwMask,
pDialParams,
fDelete);
}
/*++
Routine Description:
Create a rasapi32 connection.
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasCreateConnection(
HCONN *lphconn,
DWORD dwSubEntries,
DWORD *lpdwEntryAlreadyConnected,
DWORD *lpdwSubEntryInfo,
DWORD dwDialMode,
GUID *pGuidEntry,
CHAR *lpszPhonebookPath,
CHAR *lpszEntryName,
CHAR *lpszRefPbkPath,
CHAR *lpszRefEntryName
)
{
return SubmitRequest ( NULL,
REQTYPE_CREATECONNECTION,
GetCurrentProcessId(),
dwSubEntries,
dwDialMode,
pGuidEntry,
lpszPhonebookPath,
lpszEntryName,
lpszRefPbkPath,
lpszRefEntryName,
lphconn,
lpdwEntryAlreadyConnected,
lpdwSubEntryInfo);
}
/*++
Routine Description:
Return a list of active HCONNs
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasConnectionEnum(
HANDLE hConnection,
HCONN *lphconn,
LPDWORD lpdwcbConnections,
LPDWORD lpdwcConnections
)
{
DWORD dwError = SUCCESS;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest (hConnection,
REQTYPE_ENUMCONNECTION,
lpdwcbConnections,
lphconn,
lpdwcConnections);
done:
return dwError;
}
/*++
Routine Description:
Associate a rasapi32 connection with a port
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasAddConnectionPort(
HCONN hconn,
HPORT hport,
DWORD dwSubEntry
)
{
return SubmitRequest ( NULL,
REQTYPE_ADDCONNECTIONPORT,
hconn,
hport,
dwSubEntry);
}
/*++
Routine Description:
Enumerate all ports in a connection
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasEnumConnectionPorts(
HANDLE hConnection,
HCONN hconn,
RASMAN_PORT *lpPorts,
LPDWORD lpdwcbPorts,
LPDWORD lpdwcPorts
)
{
DWORD dwError = SUCCESS;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest (hConnection,
REQTYPE_ENUMCONNECTIONPORTS,
hconn,
lpdwcbPorts,
lpPorts,
lpdwcPorts);
done:
return dwError;
}
/*++
Routine Description:
Destroy a rasapi32 connection.
Arguments:
Return Value:
SUCCESS
ERROR_NOT_ENOUGH_MEMORY
ERROR_ACCESS_DENIED
whatever RasEnumConnectionPorts returns
--*/
DWORD APIENTRY
RasDestroyConnection(
HCONN hconn
)
{
RASMAN_PORT *lpPorts = NULL;
DWORD dwPort;
DWORD dwcbPorts;
DWORD dwcPorts;
DWORD dwError = SUCCESS;
DWORD dwLastError = SUCCESS;
//
// allocate buffer for 2 ports up front
// We don't have to make more than one
// rasman call in base cases.
//
lpPorts = LocalAlloc(LPTR,
2 * sizeof(RASMAN_PORT));
if (NULL == lpPorts)
{
dwError = ERROR_NOT_ENOUGH_MEMORY;
goto done;
}
dwcbPorts = 2 * sizeof(RASMAN_PORT);
do {
//
// enumerate the ports in this connection
//
dwError = RasEnumConnectionPorts(NULL,
hconn,
lpPorts,
&dwcbPorts,
&dwcPorts);
if (ERROR_BUFFER_TOO_SMALL == dwError)
{
LocalFree(lpPorts);
lpPorts = NULL;
//
// allocate a larger buffer and call the api again
//
lpPorts = LocalAlloc(LPTR, dwcbPorts);
if (NULL == lpPorts)
{
dwError = ERROR_NOT_ENOUGH_MEMORY;
}
}
} while (ERROR_BUFFER_TOO_SMALL == dwError);
if (SUCCESS != dwError)
{
goto done;
}
for (dwPort = 0; dwPort < dwcPorts; dwPort++)
{
//
//disconnect the port
//
dwError = RasPortDisconnect( lpPorts[dwPort].P_Handle,
INVALID_HANDLE_VALUE);
if(ERROR_SUCCESS != dwError)
{
dwLastError = dwError;
}
//
// close the port
//
dwError = RasPortClose( lpPorts[dwPort].P_Handle );
if(ERROR_SUCCESS != dwError)
{
dwLastError = dwError;
}
}
done:
if (lpPorts)
{
LocalFree(lpPorts);
}
if( (ERROR_SUCCESS == dwError)
&& (ERROR_SUCCESS != dwLastError))
{
dwError = dwLastError;
}
return dwError;
}
/*++
Routine Description:
Retrieve rasapi32 bandwidth-on-demand, idle disconnect,
and redial-on-link-failure parameters for a bundle
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasGetConnectionParams(
HCONN hconn,
PRAS_CONNECTIONPARAMS pConnectionParams
)
{
return SubmitRequest ( NULL,
REQTYPE_GETCONNECTIONPARAMS,
hconn,
pConnectionParams);
}
/*++
Routine Description:
Store rasapi32 bandwidth-on-demand, idle disconnect,
and redial-on-link-failure parameters for a bundle
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasSetConnectionParams(
HCONN hconn,
PRAS_CONNECTIONPARAMS pConnectionParams
)
{
return SubmitRequest ( NULL,
REQTYPE_SETCONNECTIONPARAMS,
hconn,
pConnectionParams);
}
/*++
Routine Description:
Retrieve tagged user data for a connection
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasGetConnectionUserData(
HCONN hconn,
DWORD dwTag,
PBYTE pBuf,
LPDWORD lpdwcbBuf
)
{
return SubmitRequest ( NULL,
REQTYPE_GETCONNECTIONUSERDATA,
hconn,
dwTag,
pBuf,
lpdwcbBuf);
}
/*++
Routine Description:
Store tagged user data for a connection
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasSetConnectionUserData(
HCONN hconn,
DWORD dwTag,
PBYTE pBuf,
DWORD dwcbBuf
)
{
return SubmitRequest ( NULL,
REQTYPE_SETCONNECTIONUSERDATA,
hconn,
dwTag,
pBuf,
dwcbBuf);
}
/*++
Routine Description:
Retrieve tagged user data for a port
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasGetPortUserData(
HPORT hport,
DWORD dwTag,
PBYTE pBuf,
LPDWORD lpdwcbBuf
)
{
return SubmitRequest ( NULL,
REQTYPE_GETPORTUSERDATA,
hport,
dwTag,
pBuf,
lpdwcbBuf);
}
/*++
Routine Description:
Store tagged user data for a port
Arguments:
Return Value:
SUCCESS
--*/
DWORD APIENTRY
RasSetPortUserData(
HPORT hport,
DWORD dwTag,
PBYTE pBuf,
DWORD dwcbBuf
)
{
return SubmitRequest ( NULL,
REQTYPE_SETPORTUSERDATA,
hport,
dwTag,
pBuf,
dwcbBuf);
}
/*++
Routine Description:
Sends message to rasman.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasSendPppMessageToRasman (
IN HPORT hPort,
LPBYTE lpPppMessage
)
{
return SubmitRequest ( NULL,
REQTYPE_SENDPPPMESSAGETORASMAN,
hPort,
lpPppMessage);
}
/*++
Routine Description:
Stops PPP on 'hPort'.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasPppStop(
IN HPORT hPort
)
{
if (ValidatePortHandle (hPort) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest( NULL,
REQTYPE_PPPSTOP,
hPort );
}
/*++
Routine Description:
Called in response to a "CallbackRequest" notification to
set the callback number (or not) for the "set-by-caller"
user.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasPppCallback(
IN HPORT hPort,
IN CHAR* pszCallbackNumber
)
{
if (ValidatePortHandle (hPort) == FALSE)
return ERROR_INVALID_PORT_HANDLE ;
return SubmitRequest ( NULL,
REQTYPE_PPPCALLBACK,
hPort,
pszCallbackNumber );
}
/*++
Routine Description:
Called in response to a "ChangePwRequest" notification
to set a new password (replacing the one that has expired)
of 'pszNewPassword'. The username and old password are
specified because in the auto-logon case they have not
yet been specified in change password useable form.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasPppChangePassword(
IN HPORT hPort,
IN CHAR* pszUserName,
IN CHAR* pszOldPassword,
IN CHAR* pszNewPassword )
{
if (ValidatePortHandle (hPort) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest( NULL,
REQTYPE_PPPCHANGEPWD,
hPort,
pszUserName,
pszOldPassword,
pszNewPassword );
}
/*++
Routine Description:
Called when the PPP event is set to retrieve the latest PPP
** notification info which is loaded into caller's 'pMsg'
buffer.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasPppGetInfo(
IN HPORT hPort,
OUT PPP_MESSAGE* pMsg
)
{
if (ValidatePortHandle (hPort) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest( NULL,
REQTYPE_PPPGETINFO,
hPort,
pMsg );
}
/*++
Routine Description:
Called in response to an "AuthRetry" notification to retry
authentication with the new credentials, 'pszUserName',
'pszPassword', and 'pszDomain'.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasPppRetry(
IN HPORT hPort,
IN CHAR* pszUserName,
IN CHAR* pszPassword,
IN CHAR* pszDomain
)
{
if (ValidatePortHandle (hPort) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest( NULL,
REQTYPE_PPPRETRY,
hPort,
pszUserName,
pszPassword,
pszDomain );
}
/*++
Routine Description:
Starts PPP on open and connected RAS Manager port 'hPort'.
If successful, 'hEvent' (a manual-reset event) is thereafter
set whenever a PPP notification is available (via RasPppGetInfo).
'pszUserName', 'pszPassword', and 'pszDomain' specify the
credentials to be authenticated during authentication phase.
'pConfigInfo' specifies further configuration info such as
which CPs to request, callback and compression parameters,
etc. 'pszzParameters' is a buffer of length PARAMETERBUFLEN
containing a string of NUL-terminated key=value strings,
all terminated by a double-NUL.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasPppStart(
IN HPORT hPort,
IN CHAR* pszPortName,
IN CHAR* pszUserName,
IN CHAR* pszPassword,
IN CHAR* pszDomain,
IN LUID* pLuid,
IN PPP_CONFIG_INFO* pConfigInfo,
IN LPVOID pInterfaceInfo,
IN CHAR* pszzParameters,
IN BOOL fThisIsACallback,
IN HANDLE hEvent,
IN DWORD dwAutoDisconnectTime,
IN BOOL fRedialOnLinkFailure,
IN PPP_BAPPARAMS* pBapParams,
IN BOOL fNonInteractive,
IN DWORD dwEapTypeId,
IN DWORD dwFlags
)
{
PPP_INTERFACE_INFO * pPppInterfaceInfo = pInterfaceInfo;
if (ValidatePortHandle (hPort) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
//
// If user name is not NULL and password is
// NULL and this is not the svchost process,
// get the user sid and save it in the ports
// user data
//
if(!IsRasmanProcess())
{
DWORD dwErr;
PWCHAR pszSid = LocalAlloc(LPTR, 5000);
if(NULL != pszSid)
{
dwErr = GetUserSid(pszSid, 5000);
if(ERROR_SUCCESS == dwErr)
{
dwErr = RasSetPortUserData(
hPort,
PORT_USERSID_INDEX,
(PBYTE) pszSid,
5000);
}
LocalFree(pszSid);
}
else
{
RasmanOutputDebug("RASMAN: RasPppStart: failed to allocate sid\n");
}
}
return SubmitRequest( NULL,
REQTYPE_PPPSTART,
hPort,
pszPortName,
pszUserName,
pszPassword,
pszDomain,
pLuid,
pConfigInfo,
pPppInterfaceInfo,
pszzParameters,
fThisIsACallback,
hEvent,
GetCurrentProcessId(),
dwAutoDisconnectTime,
fRedialOnLinkFailure,
pBapParams,
fNonInteractive,
dwEapTypeId,
dwFlags);
}
/*++
Routine Description:
Adds an event to be signalled on disconnect
state for either an existing connection, or an
existing port.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasAddNotification(
IN HCONN hconn,
IN HANDLE hevent,
IN DWORD dwfFlags
)
{
DWORD pid = GetCurrentProcessId();
return SubmitRequest ( NULL,
REQTYPE_ADDNOTIFICATION,
pid,
hconn,
hevent,
dwfFlags );
}
/*++
Routine Description:
Allows rasapi32 to notify rasman when a new connection
is ready to have data sent over it.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasSignalNewConnection(
IN HCONN hconn
)
{
return SubmitRequest( NULL,
REQTYPE_SIGNALCONNECTION,
hconn );
}
/*++
Routine Description:
Allows apps to set dev config that is specific to the device.
This is passed on to the approp. media dll
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasSetDevConfig( IN HPORT hport,
IN CHAR *devicetype,
IN PBYTE config,
IN DWORD size)
{
if (ValidatePortHandle (hport) == FALSE)
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_SETDEVCONFIG,
hport,
devicetype,
config,
size);
}
/*++
Routine Description:
Allows apps to get dev config that is specific to the device.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasGetDevConfig ( IN HANDLE hConnection,
IN HPORT hport,
IN CHAR *devicetype,
IN PBYTE config,
IN OUT DWORD *size)
{
DWORD dwError = SUCCESS;
RAS_RPC *pRasRpcConnection = (RAS_RPC *) hConnection;
if (ValidatePortHandle (hport) == FALSE)
{
dwError = ERROR_INVALID_PORT_HANDLE;
goto done;
}
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
//
// If the request is for a remote server and the server
// version is 4.0 - steelhead, then defer to the old way
// of getting this information since rasman has become
// a rpc server only in version 50.
//
if( NULL != pRasRpcConnection
&& VERSION_40 == pRasRpcConnection->dwVersion)
{
DWORD dwSizeRequired = *size;
dwError = RemoteRasGetDevConfig(hConnection,
hport,
devicetype,
config,
&dwSizeRequired);
//
// Since this is a buffer returned from a 4.0
// server, we need to change this to a format
// that nt 5.0 understands.
//
if( (SUCCESS == dwError)
&& (dwSizeRequired > 0)
&& (*size >= (dwSizeRequired + sizeof(RAS_DEVCONFIG))))
{
RAS_DEVCONFIG *pDevConfig = (RAS_DEVCONFIG *) config;
MoveMemory((PBYTE) pDevConfig->abInfo,
config,
dwSizeRequired);
pDevConfig->dwOffsetofModemSettings =
FIELD_OFFSET(RAS_DEVCONFIG, abInfo);
pDevConfig->dwSizeofModemSettings = dwSizeRequired;
pDevConfig->dwSizeofExtendedCaps = 0;
pDevConfig->dwOffsetofExtendedCaps = 0;
}
else if ( (dwSizeRequired > 0)
&& (*size < (dwSizeRequired + sizeof(RAS_DEVCONFIG))))
{
dwError = ERROR_BUFFER_TOO_SMALL;
}
else if (dwSizeRequired > 0)
{
*size = dwSizeRequired + sizeof(RAS_DEVCONFIG);
}
else
{
*size = dwSizeRequired;
}
}
else
{
dwError = SubmitRequest (hConnection,
REQTYPE_GETDEVCONFIG,
hport,
devicetype,
config,
size);
}
done:
return dwError;
}
/*++
Routine Description:
Gets time in seconds from NDISWAN since the last activity on
this port
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasGetTimeSinceLastActivity(
IN HPORT hport,
OUT LPDWORD lpdwTimeSinceLastActivity
)
{
if (ValidatePortHandle (hport) == FALSE)
{
return( ERROR_INVALID_PORT_HANDLE );
}
return SubmitRequest( NULL,
REQTYPE_GETTIMESINCELASTACTIVITY,
hport,
lpdwTimeSinceLastActivity );
}
/*++
Routine Description:
Debug routine to test PnP operations
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasPnPControl(
IN DWORD dwOp,
IN HPORT hport
)
{
return SubmitRequest( NULL,
REQTYPE_PNPCONTROL,
dwOp,
hport );
}
/*++
Routine Description:
Set the I/O Completion Port associated with a port.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasSetIoCompletionPort(
IN HPORT hport,
IN HANDLE hIoCompletionPort,
IN PRAS_OVERLAPPED lpOvDrop,
IN PRAS_OVERLAPPED lpOvStateChange,
IN PRAS_OVERLAPPED lpOvPpp,
IN PRAS_OVERLAPPED lpOvLast,
IN HRASCONN hConn
)
{
return SubmitRequest(
NULL,
REQTYPE_SETIOCOMPLETIONPORT,
hport,
hIoCompletionPort,
lpOvDrop,
lpOvStateChange,
lpOvPpp,
lpOvLast,
hConn);
}
/*++
Routine Description:
Set the I/O Completion Port associated with a port.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasSetRouterUsage(
IN HPORT hport,
IN BOOL fRouter
)
{
return SubmitRequest(
NULL,
REQTYPE_SETROUTERUSAGE,
hport,
fRouter);
}
/*++
Routine Description:
Close the server's side of a port.
Arguments:
Return Value:
SUCCESS
Non-zero returns - Failure
--*/
DWORD APIENTRY
RasServerPortClose(
IN HPORT hport
)
{
DWORD pid = GetCurrentProcessId();
if (!ValidatePortHandle (hport))
{
return ERROR_INVALID_PORT_HANDLE ;
}
return SubmitRequest ( NULL,
REQTYPE_SERVERPORTCLOSE,
hport,
pid,
TRUE) ;
}
DWORD APIENTRY
RasSetRasdialInfo (
IN HPORT hport,
IN CHAR *pszPhonebookPath,
IN CHAR *pszEntryName,
IN CHAR *pszPhoneNumber,
IN DWORD cbCustomAuthData,
IN PBYTE pbCustomAuthData)
{
if (!ValidatePortHandle (hport))
{
return ERROR_INVALID_PORT_HANDLE;
}
return SubmitRequest ( NULL,
REQTYPE_SETRASDIALINFO,
hport,
pszPhonebookPath,
pszEntryName,
pszPhoneNumber,
cbCustomAuthData,
pbCustomAuthData);
}
DWORD
RasRegisterPnPCommon ( PVOID pvNotifier,
HANDLE hAlertableThread,
DWORD dwFlags,
BOOL fRegister)
{
DWORD dwErr;
DWORD pid = GetCurrentProcessId();
HANDLE hThreadHandle = NULL;
if ( NULL == pvNotifier
|| ( 0 == ( dwFlags & PNP_NOTIFEVENT )
&& 0 == ( dwFlags & PNP_NOTIFCALLBACK )))
{
dwErr = ERROR_INVALID_PARAMETER;
goto done;
}
if ( dwFlags & PNP_NOTIFCALLBACK )
{
if (fRegister )
{
if(NULL == hAlertableThread )
{
RasmanOutputDebug ("RasRegisterPnPCommon: "
"hAlertableThread == NULL\n");
dwErr = ERROR_INVALID_PARAMETER;
goto done;
}
if ( !DuplicateHandle( GetCurrentProcess(),
hAlertableThread,
GetCurrentProcess(),
&hThreadHandle,
0,
FALSE,
DUPLICATE_SAME_ACCESS ) )
{
RasmanOutputDebug("RasRegisterPnPCommon: Failed to"
" duplicate handle\n");
dwErr = GetLastError();
goto done;
}
}
}
dwErr = SubmitRequest ( NULL,
REQTYPE_REGISTERPNPNOTIF,
pvNotifier,
dwFlags,
pid,
hThreadHandle,
fRegister);
done:
return dwErr;
}
DWORD APIENTRY
RasRegisterPnPEvent ( HANDLE hEvent, BOOL fRegister )
{
DWORD pid = GetCurrentProcessId ();
return RasRegisterPnPCommon ( (PVOID) hEvent,
NULL,
PNP_NOTIFEVENT,
fRegister);
}
DWORD APIENTRY
RasRegisterPnPHandler(PAPCFUNC pfnPnPHandler,
HANDLE hAlertableThread,
BOOL fRegister)
{
return RasRegisterPnPCommon ( (PVOID) pfnPnPHandler,
hAlertableThread,
PNP_NOTIFCALLBACK,
fRegister);
}
DWORD APIENTRY
RasGetAttachedCount ( DWORD *pdwAttachedCount )
{
return SubmitRequest ( NULL,
REQTYPE_GETATTACHEDCOUNT,
pdwAttachedCount );
}
DWORD APIENTRY
RasGetNumPortOpen (void)
{
return SubmitRequest ( NULL,
REQTYPE_NUMPORTOPEN );
}
DWORD APIENTRY
RasSetBapPolicy ( HCONN hConn,
DWORD dwLowThreshold,
DWORD dwLowSamplePeriod,
DWORD dwHighThreshold,
DWORD dwHighSamplePeriod)
{
return SubmitRequest ( NULL,
REQTYPE_SETBAPPOLICY,
hConn,
dwLowThreshold,
dwLowSamplePeriod,
dwHighThreshold,
dwHighSamplePeriod );
}
DWORD APIENTRY
RasPppStarted ( HPORT hPort )
{
return SubmitRequest ( NULL,
REQTYPE_PPPSTARTED,
hPort );
}
DWORD APIENTRY
RasRefConnection( HCONN hConn,
BOOL fAddref,
DWORD *pdwRefCount )
{
return SubmitRequest ( NULL,
REQTYPE_REFCONNECTION,
hConn,
fAddref,
pdwRefCount );
}
DWORD APIENTRY
RasPppGetEapInfo( HCONN hConn,
DWORD dwSubEntry,
DWORD *pdwContextId,
DWORD *pdwEapTypeId,
DWORD *pdwSizeOfUIData,
PBYTE pbdata )
{
return SubmitRequest( NULL,
REQTYPE_GETEAPINFO,
hConn,
dwSubEntry,
pdwSizeOfUIData,
pbdata,
pdwContextId,
pdwEapTypeId);
}
DWORD APIENTRY
RasPppSetEapInfo( HPORT hPort,
DWORD dwContextId,
DWORD dwSizeOfEapUIData,
PBYTE pbdata)
{
return SubmitRequest( NULL,
REQTYPE_SETEAPINFO,
hPort,
dwContextId,
dwSizeOfEapUIData,
pbdata);
}
DWORD APIENTRY
RasSetDeviceConfigInfo( HANDLE hConnection,
DWORD cEntries,
DWORD cbBuffer,
BYTE *pbBuffer
)
{
DWORD dwError = SUCCESS;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest( hConnection,
REQTYPE_SETDEVICECONFIGINFO,
cEntries,
cbBuffer,
pbBuffer);
done:
return dwError;
}
DWORD APIENTRY
RasGetDeviceConfigInfo( HANDLE hConnection,
DWORD *pdwVersion,
DWORD *pcEntries,
DWORD *pcbdata,
BYTE *pbBuffer)
{
DWORD dwError = SUCCESS;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest( hConnection,
REQTYPE_GETDEVICECONFIGINFO,
pdwVersion,
pcbdata,
pbBuffer,
pcEntries);
done:
return dwError;
}
DWORD APIENTRY
RasFindPrerequisiteEntry( HCONN hConn,
HCONN *phConnPrerequisiteEntry)
{
return SubmitRequest( NULL,
REQTYPE_FINDPREREQUISITEENTRY,
hConn,
phConnPrerequisiteEntry);
}
DWORD APIENTRY
RasLinkGetStatistics( HANDLE hConnection,
HCONN hConn,
DWORD dwSubEntry,
PBYTE pbStats)
{
DWORD dwError = SUCCESS;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest( hConnection,
REQTYPE_GETLINKSTATS,
hConn,
dwSubEntry,
pbStats);
done:
return dwError;
}
DWORD APIENTRY
RasConnectionGetStatistics(HANDLE hConnection,
HCONN hConn,
PBYTE pbStats)
{
DWORD dwError = SUCCESS;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest( hConnection,
REQTYPE_GETCONNECTIONSTATS,
hConn,
pbStats);
done:
return dwError;
}
DWORD APIENTRY
RasGetHportFromConnection(HANDLE hConnection,
HCONN hConn,
HPORT *phport)
{
DWORD dwError = SUCCESS;
if(!ValidateConnectionHandle(hConnection))
{
dwError = E_INVALIDARG;
goto done;
}
dwError = SubmitRequest(hConnection,
REQTYPE_GETHPORTFROMCONNECTION,
hConn,
phport);
done:
return dwError;
}
DWORD APIENTRY
RasReferenceCustomCount(HCONN hConn,
BOOL fAddref,
CHAR* pszPhonebookPath,
CHAR* pszEntryName,
DWORD* pdwCount)
{
return SubmitRequest(NULL,
REQTYPE_REFERENCECUSTOMCOUNT,
hConn,
fAddref,
pszPhonebookPath,
pszEntryName,
pdwCount);
}
DWORD APIENTRY
RasGetHConnFromEntry(HCONN *phConn,
CHAR *pszPhonebookPath,
CHAR *pszEntryName)
{
return SubmitRequest(NULL,
REQTYPE_GETHCONNFROMENTRY,
pszPhonebookPath,
pszEntryName,
phConn);
}
DWORD APIENTRY
RasGetConnectInfo(HPORT hPort,
DWORD *pdwSize,
RAS_CONNECT_INFO *pConnectInfo)
{
if(NULL == pdwSize)
{
return E_INVALIDARG;
}
return SubmitRequest(NULL,
REQTYPE_GETCONNECTINFO,
hPort,
pdwSize,
pConnectInfo);
}
DWORD APIENTRY
RasGetDeviceName(RASDEVICETYPE eDeviceType,
CHAR *pszDeviceName)
{
if(NULL == pszDeviceName)
{
return E_INVALIDARG;
}
return SubmitRequest(NULL,
REQTYPE_GETDEVICENAME,
eDeviceType,
pszDeviceName);
}
DWORD APIENTRY
RasGetDeviceNameW(RASDEVICETYPE eDeviceType,
WCHAR *pszDeviceName)
{
if(NULL == pszDeviceName)
{
return E_INVALIDARG;
}
return SubmitRequest(NULL,
REQTYPE_GETDEVICENAMEW,
eDeviceType,
pszDeviceName);
}
DWORD APIENTRY
RasGetCalledIdInfo(HANDLE hConnection,
RAS_DEVICE_INFO *pDeviceInfo,
DWORD *pdwSize,
RAS_CALLEDID_INFO *pCalledIdInfo)
{
if( (NULL == pDeviceInfo)
|| (NULL == pdwSize))
{
return E_INVALIDARG;
}
return SubmitRequest(hConnection,
REQTYPE_GETCALLEDID,
pDeviceInfo,
pdwSize,
pCalledIdInfo);
}
DWORD APIENTRY
RasSetCalledIdInfo(HANDLE hConnection,
RAS_DEVICE_INFO *pDeviceInfo,
RAS_CALLEDID_INFO *pCalledIdInfo,
BOOL fWrite)
{
if( (NULL == pDeviceInfo)
|| (NULL == pCalledIdInfo))
{
return E_INVALIDARG;
}
return SubmitRequest(hConnection,
REQTYPE_SETCALLEDID,
pDeviceInfo,
pCalledIdInfo,
fWrite);
}
DWORD APIENTRY
RasEnableIpSec(HPORT hPort,
BOOL fEnable,
BOOL fServer,
RAS_L2TP_ENCRYPTION eEncryption)
{
DWORD retcode = ERROR_SUCCESS;
retcode = SubmitRequest(NULL,
REQTYPE_ENABLEIPSEC,
hPort,
fEnable,
fServer,
eEncryption);
if( (ERROR_SUCCESS != retcode)
&& (ERROR_CERT_FOR_ENCRYPTION_NOT_FOUND != retcode)
&& (ERROR_NO_CERTIFICATE != retcode))
{
if(!fServer)
{
return ERROR_FAILED_TO_ENCRYPT;
}
}
return retcode;
}
DWORD APIENTRY
RasIsIpSecEnabled(HPORT hPort,
BOOL *pfIsIpSecEnabled)
{
if(NULL == pfIsIpSecEnabled)
{
return E_INVALIDARG;
}
return SubmitRequest(NULL,
REQTYPE_ISIPSECENABLED,
hPort,
pfIsIpSecEnabled);
}
DWORD APIENTRY
RasGetEapUserInfo(HANDLE hToken,
PBYTE pbEapInfo,
DWORD *pdwInfoSize,
GUID *pGuid,
BOOL fRouter,
DWORD dwEapTypeId)
{
return DwGetEapUserInfo(hToken,
pbEapInfo,
pdwInfoSize,
pGuid,
fRouter,
dwEapTypeId);
}
DWORD APIENTRY
RasSetEapUserInfo(HANDLE hToken,
GUID *pGuid,
PBYTE pbUserInfo,
DWORD dwInfoSize,
BOOL fClear,
BOOL fRouter,
DWORD dwEapTypeId)
{
return DwSetEapUserInfo(hToken,
pGuid,
pbUserInfo,
dwInfoSize,
fClear,
fRouter,
dwEapTypeId);
}
DWORD APIENTRY
RasSetEapLogonInfo(HPORT hPort,
BOOL fLogon,
RASEAPINFO *pEapInfo)
{
ASSERT(NULL != pEapInfo);
return SubmitRequest(NULL,
REQTYPE_SETEAPLOGONINFO,
hPort,
fLogon,
pEapInfo);
}
DWORD APIENTRY
RasSendNotification(RASEVENT *pRasEvent)
{
ASSERT(NULL != pRasEvent);
return SubmitRequest(NULL,
REQTYPE_SENDNOTIFICATION,
pRasEvent);
}
DWORD APIENTRY RasGetNdiswanDriverCaps(
HANDLE hConnection,
RAS_NDISWAN_DRIVER_INFO *pInfo)
{
if(NULL == pInfo)
{
return E_INVALIDARG;
}
return SubmitRequest(hConnection,
REQTYPE_GETNDISWANDRIVERCAPS,
pInfo);
}
DWORD APIENTRY RasGetBandwidthUtilization(
HPORT hPort,
RAS_GET_BANDWIDTH_UTILIZATION *pUtilization)
{
if(NULL == pUtilization)
{
return E_INVALIDARG;
}
return SubmitRequest(NULL,
REQTYPE_GETBANDWIDTHUTILIZATION,
hPort,
pUtilization);
}
/*++
Routine Description:
This function allows rasauto.dll to provide
a callback procedure that gets invoked when
a connection is terminated due to hardware
failure on its remaining link.
Arguments:
Return Value:
--*/
VOID
RasRegisterRedialCallback(
LPVOID func
)
{
if(NULL == g_fnServiceRequest)
{
goto done;
}
(void) SubmitRequest(NULL,
REQTYPE_REGISTERREDIALCALLBACK,
func);
done:
return;
}
DWORD APIENTRY RasGetProtocolInfo(
HANDLE hConnection,
RASMAN_GET_PROTOCOL_INFO *pInfo)
{
if(NULL == pInfo)
{
return E_INVALIDARG;
}
return SubmitRequest(NULL,
REQTYPE_GETPROTOCOLINFO,
pInfo);
}
DWORD APIENTRY RasGetCustomScriptDll(
CHAR *pszCustomDll)
{
if(NULL == pszCustomDll)
{
return E_INVALIDARG;
}
return SubmitRequest(
NULL,
REQTYPE_GETCUSTOMSCRIPTDLL,
pszCustomDll);
}
DWORD APIENTRY RasIsTrustedCustomDll(
HANDLE hConnection,
WCHAR *pwszCustomDll,
BOOL *pfTrusted)
{
if( (NULL == pwszCustomDll)
|| (wcslen(pwszCustomDll) > MAX_PATH)
|| (NULL == pfTrusted))
{
return E_INVALIDARG;
}
*pfTrusted = FALSE;
if(IsKnownDll(pwszCustomDll))
{
*pfTrusted = TRUE;
return SUCCESS;
}
return SubmitRequest(
NULL,
REQTYPE_ISTRUSTEDCUSTOMDLL,
pwszCustomDll,
pfTrusted);
}
DWORD APIENTRY RasDoIke(
HANDLE hConnection,
HPORT hPort,
DWORD *pdwStatus)
{
DWORD retcode = ERROR_SUCCESS;
HANDLE hEvent = NULL;
ASSERT(NULL != pdwStatus);
if(NULL == (hEvent = CreateEvent(
NULL,
FALSE,
FALSE,
NULL)))
{
retcode = GetLastError();
goto done;
}
retcode = SubmitRequest(
NULL,
REQTYPE_DOIKE,
hPort,
hEvent);
if(SUCCESS == retcode)
{
DWORD dwRet;
for(;;)
{
//
// go into wait and keep checking to see
// if the port has been disconnected.
//
dwRet = WaitForSingleObject(hEvent, SECS_WaitTimeOut);
if(WAIT_TIMEOUT == dwRet)
{
RASMAN_INFO ri;
retcode = SubmitRequest(
NULL,
REQTYPE_GETINFO,
hPort,
&ri);
if( (ERROR_SUCCESS == retcode)
&& (CLOSED != ri.RI_PortStatus)
&& (LISTENING != ri.RI_ConnState))
{
continue;
}
else
{
break;
}
}
else
{
if (WAIT_OBJECT_0 == dwRet)
{
retcode = SubmitRequest(
NULL,
REQTYPE_QUERYIKESTATUS,
hPort,
pdwStatus);
}
break;
}
}
}
if(E_ABORT == retcode)
{
retcode = SUCCESS;
}
done:
if(NULL != hEvent)
{
CloseHandle(hEvent);
}
return retcode;
}
DWORD APIENTRY RasSetCommSettings(
HPORT hPort,
RASCOMMSETTINGS *pRasCommSettings,
PVOID pv)
{
UNREFERENCED_PARAMETER(pv);
if(NULL == pRasCommSettings)
{
E_INVALIDARG;
}
if( (sizeof(RASCOMMSETTINGS) != pRasCommSettings->dwSize)
|| sizeof(RASMANCOMMSETTINGS) != sizeof(RASCOMMSETTINGS))
{
ASSERT(FALSE);
return ERROR_INVALID_SIZE;
}
return SubmitRequest(
NULL,
REQTYPE_SETRASCOMMSETTINGS,
hPort,
pRasCommSettings);
}
DWORD
RasSetKey(
HANDLE hConnection,
GUID *pGuid,
DWORD dwMask,
DWORD cbkey,
PBYTE pbkey)
{
return SubmitRequest(
hConnection,
REQTYPE_SETKEY,
pGuid,
dwMask,
cbkey,
pbkey);
}
DWORD
RasGetKey(
HANDLE hConnection,
GUID *pGuid,
DWORD dwMask,
DWORD *pcbkey,
PBYTE pbkey)
{
return SubmitRequest(
hConnection,
REQTYPE_GETKEY,
pGuid,
dwMask,
pcbkey,
pbkey);
}
DWORD
RasSetAddressDisable(
WCHAR *pszAddress,
BOOL fDisable)
{
return SubmitRequest(
NULL,
REQTYPE_ADDRESSDISABLE,
pszAddress,
fDisable);
}
DWORD APIENTRY
RasGetDevConfigEx ( IN HANDLE hConnection,
IN HPORT hport,
IN CHAR *devicetype,
IN PBYTE config,
IN OUT DWORD *size)
{
return SubmitRequest(
hConnection,
REQTYPE_GETDEVCONFIGEX,
hport,
devicetype,
config,
size
);
}
DWORD APIENTRY
RasSendCreds(IN HPORT hport,
IN CHAR controlchar)
{
return SubmitRequest(
NULL,
REQTYPE_SENDCREDS,
hport,
controlchar);
}
DWORD APIENTRY
RasGetUnicodeDeviceName(IN HPORT hport,
IN WCHAR *wszDeviceName)
{
return SubmitRequest(
NULL,
REQTYPE_GETUNICODEDEVICENAME,
hport,
wszDeviceName);
}
DWORD APIENTRY
RasGetBestInterface( IN DWORD DestAddr,
OUT DWORD *pdwBestIf,
OUT DWORD *pdwMask)
{
return SubmitRequest(
NULL,
REQTYPE_GETBESTINTERFACE,
DestAddr,
pdwBestIf,
pdwMask);
}
DWORD APIENTRY
RasIsPulseDial(IN HPORT hport,
OUT BOOL *pfPulse)
{
return SubmitRequest(
NULL,
REQTYPE_ISPULSEDIAL,
hport,
pfPulse);
}