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.
5065 lines
135 KiB
5065 lines
135 KiB
/*++
|
|
|
|
Copyright (C) 1992-98 Microsft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
init.c
|
|
|
|
Abstract:
|
|
|
|
This file contains init code for TAPI.DLL
|
|
|
|
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 <stdio.h>
|
|
#include <windows.h>
|
|
#include <tapi.h>
|
|
#include <rasman.h>
|
|
#include <raserror.h>
|
|
#include <mprlog.h>
|
|
#include <rtutils.h>
|
|
|
|
#include <media.h>
|
|
#include <device.h>
|
|
#include <rasmxs.h>
|
|
#include <isdn.h>
|
|
#include <stdlib.h>
|
|
#include <malloc.h>
|
|
#include <string.h>
|
|
#include "rastapi.h"
|
|
#include "reghelp.h"
|
|
#include <ntddndis.h> //for NDIS_WAN_MEDIUM_SUBTYPE
|
|
|
|
#define STRSAFE_NO_DEPRECATE
|
|
#include <strsafe.h>
|
|
|
|
#define NUMBUFFERS 10
|
|
|
|
extern DWORD dwTraceId;
|
|
|
|
DWORD g_dwTotalDialIn = 0;
|
|
BOOL g_fRestrictDialIn = FALSE;
|
|
|
|
DWORD APIENTRY
|
|
DeviceListen(HANDLE hPort,
|
|
char *pszDeviceType,
|
|
char *pszDeviceName);
|
|
|
|
|
|
VOID
|
|
MapNdiswanDTtoRasDT(DeviceInfo *pDeviceInfo,
|
|
NDIS_WAN_MEDIUM_SUBTYPE eMediaType);
|
|
|
|
HLINEAPP RasLine = 0 ;
|
|
HINSTANCE RasInstance = 0 ;
|
|
TapiLineInfo *RasTapiLineInfoList = NULL;
|
|
DWORD TotalLines = 0 ;
|
|
DWORD TotalPorts ;
|
|
TapiPortControlBlock *RasPortsList = NULL;
|
|
TapiPortControlBlock *RasPortsEnd ;
|
|
HANDLE RasTapiMutex ;
|
|
BOOL Initialized = FALSE ;
|
|
DWORD TapiThreadId ;
|
|
HANDLE TapiThreadHandle;
|
|
// DWORD LoaderThreadId;
|
|
DWORD ValidPorts = 0;
|
|
DWORD NumberOfRings = 2 ;
|
|
|
|
HANDLE g_hAsyMac = INVALID_HANDLE_VALUE;
|
|
|
|
HANDLE g_hIoCompletionPort = INVALID_HANDLE_VALUE;
|
|
|
|
pDeviceInfo g_pDeviceInfoList = NULL;
|
|
|
|
LIST_ENTRY ZombieCallList;
|
|
|
|
DWORD dwTraceId;
|
|
|
|
extern BOOL g_fDllLoaded;
|
|
|
|
|
|
TapiLineInfo *FindLineByHandle (HLINE) ;
|
|
|
|
TapiPortControlBlock *FindPortByRequestId (DWORD) ;
|
|
|
|
TapiPortControlBlock *FindPortByAddressId (TapiLineInfo *, DWORD) ;
|
|
|
|
TapiPortControlBlock *FindPortByAddress (CHAR *) ;
|
|
|
|
TapiPortControlBlock *FindPortByCallHandle(
|
|
TapiLineInfo *line,
|
|
HCALL callhandle);
|
|
|
|
TapiPortControlBlock *FindListeningPort(TapiLineInfo *line,
|
|
DWORD AddressID);
|
|
|
|
DWORD InitiatePortDisconnection (TapiPortControlBlock *hIOPort) ;
|
|
|
|
TapiPortControlBlock *FindPortByAddressAndName (CHAR *address,
|
|
CHAR *name) ;
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Trace
|
|
|
|
Arguments:
|
|
|
|
Formatting string,...
|
|
|
|
Return Value:
|
|
|
|
void.
|
|
--*/
|
|
|
|
VOID
|
|
RasTapiTrace(
|
|
CHAR * Format,
|
|
...
|
|
)
|
|
{
|
|
va_list arglist;
|
|
|
|
va_start(arglist, Format);
|
|
|
|
TraceVprintfEx(dwTraceId,
|
|
0x00010000 | TRACE_USE_MASK
|
|
| TRACE_USE_MSEC | TRACE_USE_DATE,
|
|
Format,
|
|
arglist);
|
|
|
|
va_end(arglist);
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initialize the RasPorts List
|
|
|
|
Arguments:
|
|
|
|
void
|
|
|
|
Return Value:
|
|
|
|
SUCCESS.
|
|
--*/
|
|
|
|
DWORD
|
|
InitializeRasPorts()
|
|
{
|
|
|
|
RasPortsList = NULL;
|
|
|
|
InitializeListHead(&ZombieCallList);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets Next available port from the list of
|
|
port control blocks. Allocates a block if
|
|
no block is available.
|
|
|
|
Arguments:
|
|
|
|
pfNewBlock -address of bool which received
|
|
if a new block was created
|
|
|
|
Return Value:
|
|
|
|
Pointer to the newly created block. NULL is
|
|
returned in case of failures.
|
|
|
|
--*/
|
|
|
|
TapiPortControlBlock *
|
|
GetNextAvailablePort( BOOL *pfNewBlock )
|
|
{
|
|
|
|
//
|
|
// Run down the global list looking for an
|
|
// unused block. If no such block is found
|
|
// allocate a new block.
|
|
//
|
|
TapiPortControlBlock *ptpcb = RasPortsList;
|
|
|
|
while ( NULL != ptpcb )
|
|
{
|
|
if ( PS_UNINITIALIZED == ptpcb->TPCB_State )
|
|
break;
|
|
|
|
ptpcb = ptpcb->TPCB_next;
|
|
}
|
|
|
|
if ( NULL != ptpcb )
|
|
{
|
|
*pfNewBlock = FALSE;
|
|
goto done;
|
|
}
|
|
|
|
ptpcb = LocalAlloc ( LPTR, sizeof ( TapiPortControlBlock ) );
|
|
|
|
if ( NULL == ptpcb )
|
|
goto done;
|
|
|
|
*pfNewBlock = TRUE;
|
|
|
|
ptpcb->TPCB_State = PS_UNINITIALIZED;
|
|
|
|
//
|
|
// insert the new block in the global list
|
|
//
|
|
ptpcb->TPCB_next = RasPortsList;
|
|
RasPortsList = ptpcb;
|
|
|
|
TotalPorts++;
|
|
|
|
done:
|
|
return ptpcb;
|
|
|
|
}
|
|
|
|
#if 0
|
|
DWORD
|
|
dwGetNextInstanceNumber(CHAR *pszMediaName,
|
|
DWORD *pdwExclusiveDialIn,
|
|
DWORD *pdwExclusiveDialOut,
|
|
DWORD *pdwExclusiveRouter,
|
|
BOOL *pfIn)
|
|
{
|
|
DWORD dwCount;
|
|
DWORD dwInstanceNum = 0;
|
|
DWORD dwTemp;
|
|
TapiPortControlBlock *ptpcb = RasPortsList;
|
|
|
|
*pdwExclusiveDialIn = 0;
|
|
*pdwExclusiveDialOut = 0;
|
|
*pdwExclusiveRouter = 0;
|
|
*pfIn = FALSE;
|
|
|
|
while ( ptpcb )
|
|
{
|
|
if ( PS_UNINITIALIZED != ptpcb->TPCB_State
|
|
&& ptpcb->TPCB_Name[0] != '\0'
|
|
&& strstr( ptpcb->TPCB_Name, pszMediaName ))
|
|
{
|
|
dwTemp = atoi(ptpcb->TPCB_Name + strlen(pszMediaName) + 1);
|
|
|
|
if (dwTemp > dwInstanceNum)
|
|
{
|
|
dwInstanceNum = dwTemp;
|
|
}
|
|
if (CALL_IN == ptpcb->TPCB_Usage)
|
|
{
|
|
*pdwExclusiveDialIn += 1;
|
|
}
|
|
else if (CALL_OUT == ptpcb->TPCB_Usage)
|
|
{
|
|
*pdwExclusiveDialOut += 1;
|
|
}
|
|
else if (CALL_ROUTER == ptpcb->TPCB_Usage)
|
|
{
|
|
*pdwExclusiveRouter += 1;
|
|
}
|
|
}
|
|
|
|
if ( CALL_IN & ptpcb->TPCB_Usage)
|
|
{
|
|
*pfIn = TRUE;
|
|
}
|
|
|
|
ptpcb = ptpcb->TPCB_next;
|
|
}
|
|
|
|
return dwInstanceNum + 1;
|
|
}
|
|
#endif
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the Guid of the adapter identified by the
|
|
dwID parameter. Also returns the media type of
|
|
the device in szMediaType parameter.
|
|
|
|
Arguments:
|
|
|
|
dwNegotiatedApiVersion
|
|
|
|
dwNegotiatedExtVersion
|
|
|
|
pbyte - buffer to receive the Guid
|
|
|
|
dwID - line Id of the device
|
|
|
|
dwAddressID - Address Id of the device
|
|
|
|
szMediaType - buffer to receive the media type
|
|
|
|
Return Value:
|
|
|
|
return codes from tapi calls. SUCCESS is
|
|
returned if there are no failures.
|
|
--*/
|
|
|
|
DWORD
|
|
dwGetLineAddress( DWORD dwNegotiatedApiVersion,
|
|
DWORD dwNegotiatedExtVersion,
|
|
LPBYTE pbyte,
|
|
DWORD dwID,
|
|
DWORD dwAddressID,
|
|
CHAR* szMediaType,
|
|
PNDIS_WAN_MEDIUM_SUBTYPE peMedia)
|
|
{
|
|
DWORD dwRetCode;
|
|
HLINE hLine = 0;
|
|
LINECALLPARAMS lineparams;
|
|
BYTE *bvar[100];
|
|
LPVARSTRING pvar;
|
|
|
|
RasTapiTrace("dwGetLineAddress:...");
|
|
|
|
//
|
|
// Open the line
|
|
//
|
|
if ( dwRetCode = lineOpen ( RasLine,
|
|
dwID,
|
|
&hLine,
|
|
dwNegotiatedApiVersion,
|
|
dwNegotiatedExtVersion,
|
|
0,
|
|
LINECALLPRIVILEGE_NONE,
|
|
LINEMEDIAMODE_UNKNOWN,
|
|
&lineparams))
|
|
{
|
|
RasTapiTrace("dwGetLineAddress: lineOpen failed. "
|
|
"0x%x", dwRetCode );
|
|
goto done;
|
|
}
|
|
|
|
pvar = (VARSTRING *) bvar;
|
|
pvar->dwTotalSize = sizeof (bvar);
|
|
|
|
//
|
|
// Get the Guid for this line from TAPI
|
|
//
|
|
if ( dwRetCode = lineGetID ( hLine,
|
|
dwAddressID,
|
|
0,
|
|
LINECALLSELECT_LINE,
|
|
pvar,
|
|
"LineGuid"))
|
|
{
|
|
RasTapiTrace("dwGetLineAddress: lineGetID LineGuid "
|
|
"failed. 0x%x", dwRetCode );
|
|
goto done;
|
|
}
|
|
|
|
|
|
lineClose (hLine);
|
|
|
|
hLine = 0;
|
|
|
|
if ( 0 != pvar->dwStringSize
|
|
&& 1 != pvar->dwStringSize)
|
|
{
|
|
DWORD Index;
|
|
UCHAR MediaTypes[][MAX_DEVICETYPE_NAME] = {
|
|
"GENERIC",
|
|
"X25",
|
|
"ISDN",
|
|
"SERIAL",
|
|
"FRAMERELAY",
|
|
"ATM",
|
|
"SONET",
|
|
"SW56",
|
|
"VPN",
|
|
"VPN",
|
|
"IRDA",
|
|
"PARALLEL",
|
|
"PPPoE"
|
|
};
|
|
|
|
//
|
|
// Copy the GUID
|
|
//
|
|
memcpy ( pbyte,
|
|
(PBYTE) (((PBYTE) pvar) +
|
|
pvar->dwStringOffset),
|
|
sizeof (GUID) );
|
|
|
|
memcpy ((PBYTE)&Index, (PBYTE) (((PBYTE) pvar) +
|
|
pvar->dwStringOffset + sizeof (GUID)),
|
|
sizeof(DWORD));
|
|
|
|
if (Index > 12) {
|
|
Index = 0;
|
|
}
|
|
|
|
//
|
|
// Copy the media name
|
|
//
|
|
strcpy (szMediaType, MediaTypes[Index]);
|
|
|
|
if(peMedia)
|
|
{
|
|
*peMedia = (NDIS_WAN_MEDIUM_SUBTYPE) Index;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASSERT(FALSE);
|
|
|
|
dwRetCode = E_FAIL;
|
|
|
|
RasTapiTrace(
|
|
"dwGetLineAddress: pvar->dwStringSize != 0,1"
|
|
" returning 0x%x",
|
|
dwRetCode);
|
|
}
|
|
|
|
done:
|
|
|
|
if (hLine)
|
|
{
|
|
lineClose (hLine);
|
|
}
|
|
|
|
RasTapiTrace("dwGetLineAddress: done. 0x%x", dwRetCode );
|
|
|
|
RasTapiTrace(" ");
|
|
|
|
return dwRetCode;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
DLL Main routine for rastapi dll.
|
|
|
|
Arguments:
|
|
|
|
hInst - instance handle of the dll
|
|
|
|
dwReason
|
|
|
|
lpReserved
|
|
|
|
Return Value:
|
|
|
|
returns 1 if successfule. 0 otherwise.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
InitRasTapi (
|
|
HANDLE hInst,
|
|
DWORD dwReason,
|
|
LPVOID lpReserved)
|
|
{
|
|
static BOOLEAN DllInitialized = FALSE ;
|
|
|
|
switch (dwReason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
|
|
if (RasPortsList != NULL)
|
|
{
|
|
return 1 ;
|
|
}
|
|
|
|
RasInstance = hInst ;
|
|
|
|
#if 0
|
|
|
|
//
|
|
// Register for tracing
|
|
//
|
|
dwTraceId = TraceRegister("RASTAPI");
|
|
|
|
#if DBG
|
|
if(dwTraceId == (DWORD) -1)
|
|
{
|
|
DbgPrint("RASTAPI: TraceRegister Failed\n");
|
|
}
|
|
else
|
|
{
|
|
DbgPrint("RASTAPI: TraceId = %d\n",
|
|
dwTraceId);
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
//
|
|
// initialize RasPorts
|
|
//
|
|
if (InitializeRasPorts())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ((RasTapiMutex = CreateMutex (NULL, FALSE, NULL))
|
|
== NULL)
|
|
{
|
|
return 0 ;
|
|
}
|
|
|
|
DllInitialized = TRUE ;
|
|
break ;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
|
|
//
|
|
// If DLL did not successfully initialize for
|
|
// this process
|
|
// dont try to clean up
|
|
//
|
|
if ( !DllInitialized
|
|
|| !g_fDllLoaded)
|
|
{
|
|
break ;
|
|
}
|
|
|
|
if (RasLine)
|
|
{
|
|
lineShutdown (RasLine) ;
|
|
RasLine = 0;
|
|
}
|
|
|
|
// TraceDeregister( dwTraceId );
|
|
|
|
g_fDllLoaded = FALSE;
|
|
|
|
PostThreadMessage (TapiThreadId, WM_QUIT, 0, 0) ;
|
|
|
|
if(NULL != TapiThreadHandle)
|
|
{
|
|
CloseHandle(TapiThreadHandle);
|
|
TapiThreadHandle = NULL;
|
|
}
|
|
|
|
break ;
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
break;
|
|
}
|
|
|
|
return 1 ;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the device information associated with
|
|
the Guid passed in if the device is not a
|
|
modem. Gets the information about modem if
|
|
the the address passed in is the device name
|
|
of a modem.
|
|
|
|
Arguments:
|
|
|
|
pbAddress - Guid of the device if fModem is
|
|
FALSE or Device Name of a modem if fModem
|
|
is TRUE.
|
|
|
|
Return Value:
|
|
|
|
Pointer to a DeviceInfo structure if the info
|
|
was found. NULL otherwise.
|
|
|
|
--*/
|
|
|
|
DeviceInfo *
|
|
GetDeviceInfo(
|
|
PBYTE pbAddress,
|
|
BOOL fModem)
|
|
{
|
|
DeviceInfo *pDeviceInfo = g_pDeviceInfoList;
|
|
|
|
while ( pDeviceInfo )
|
|
{
|
|
if( fModem
|
|
&& !_stricmp(
|
|
(CHAR *) pbAddress,
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName))
|
|
{
|
|
break;
|
|
}
|
|
else if( !fModem
|
|
&& 0 == memcmp(pbAddress,
|
|
&pDeviceInfo->rdiDeviceInfo.guidDevice,
|
|
sizeof (GUID)))
|
|
{
|
|
break;
|
|
}
|
|
|
|
pDeviceInfo = pDeviceInfo->Next;
|
|
}
|
|
|
|
return pDeviceInfo;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Trace the information in the Device Info block.
|
|
|
|
Arguments:
|
|
|
|
DeviceInfo
|
|
|
|
Return Value:
|
|
|
|
void
|
|
--*/
|
|
|
|
VOID
|
|
TraceEndPointInfo(DeviceInfo *pInfo)
|
|
{
|
|
if('\0' != pInfo->rdiDeviceInfo.szDeviceName[0])
|
|
{
|
|
RasTapiTrace("------DeviceInfo for %s--------",
|
|
pInfo->rdiDeviceInfo.szDeviceName);
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace("------DeviceInfo for Unknown----");
|
|
}
|
|
|
|
RasTapiTrace(" ");
|
|
|
|
RasTapiTrace("WanEndPoints =%d",
|
|
pInfo->rdiDeviceInfo.dwNumEndPoints);
|
|
|
|
RasTapiTrace("RasEnabled =%d",
|
|
(DWORD) pInfo->rdiDeviceInfo.fRasEnabled);
|
|
|
|
RasTapiTrace("RasEnabledRouter =%d",
|
|
(DWORD) pInfo->rdiDeviceInfo.fRouterEnabled);
|
|
|
|
RasTapiTrace("MinWanEndPoints =0x%x",
|
|
pInfo->rdiDeviceInfo.dwMinWanEndPoints);
|
|
|
|
RasTapiTrace("MaxWanEndPoints =0x%x",
|
|
pInfo->rdiDeviceInfo.dwMaxWanEndPoints);
|
|
|
|
RasTapiTrace(" ");
|
|
RasTapiTrace("------------------------------------");
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the Device information of the device
|
|
represented by the Guid. Depending on the flags
|
|
passed reads the information from registry.
|
|
Uses the functions in reghelp.lib
|
|
|
|
Arguments:
|
|
|
|
ppDeviceInfo - Address to receive the DeviceInfo
|
|
structure.
|
|
|
|
pbAddress - Guid of the device.
|
|
|
|
fForceRead - if TRUE the information is read from
|
|
the registry. If FALSE only cached information
|
|
is searched for the information on this device.
|
|
|
|
Return Value:
|
|
|
|
void
|
|
--*/
|
|
|
|
DWORD
|
|
GetEndPointInfo(DeviceInfo **ppDeviceInfo,
|
|
PBYTE pbAddress,
|
|
BOOL fForceRead,
|
|
NDIS_WAN_MEDIUM_SUBTYPE eMediaType)
|
|
{
|
|
DeviceInfo *pDeviceInfo = g_pDeviceInfoList;
|
|
DWORD retcode = SUCCESS;
|
|
DeviceInfo *pdi;
|
|
|
|
//
|
|
// Run through the device info list to see if we already
|
|
// have the device
|
|
//
|
|
if ( !fForceRead
|
|
&& ( pDeviceInfo = GetDeviceInfo(pbAddress, FALSE) ))
|
|
{
|
|
RasTapiTrace("GetEndPointInfo: Device already present");
|
|
goto done;
|
|
}
|
|
|
|
pDeviceInfo = LocalAlloc ( LPTR, sizeof ( DeviceInfo ) );
|
|
|
|
if ( NULL == pDeviceInfo )
|
|
{
|
|
retcode = GetLastError();
|
|
|
|
RasTapiTrace("GetEndPointInfo: Failed to alloc. %d",
|
|
retcode );
|
|
goto done;
|
|
}
|
|
|
|
MapNdiswanDTtoRasDT(pDeviceInfo, eMediaType);
|
|
|
|
retcode = DwGetEndPointInfo( pDeviceInfo,
|
|
pbAddress );
|
|
if ( retcode )
|
|
{
|
|
RasTapiTrace("GetEndPpointInfo: DwGetEndPointInfo "
|
|
"failed. 0x%x", retcode );
|
|
goto done;
|
|
}
|
|
|
|
pDeviceInfo->fValid = TRUE;
|
|
|
|
//
|
|
// Run through our device list and check to see if
|
|
// we already have a device with the same name. If
|
|
// we do then append the instance number of the
|
|
// device with the device name
|
|
//
|
|
pdi = g_pDeviceInfoList;
|
|
|
|
while(pdi)
|
|
{
|
|
if(!_stricmp(
|
|
pdi->rdiDeviceInfo.szDeviceName,
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName))
|
|
{
|
|
RasTapiTrace(
|
|
"GetEndPointInfo: found another"
|
|
" device with the same name %s",
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName);
|
|
|
|
break;
|
|
}
|
|
|
|
pdi = pdi->Next;
|
|
}
|
|
|
|
if(NULL != pdi)
|
|
{
|
|
CHAR szDeviceInstance[40];
|
|
WCHAR wszDeviceInstance[40];
|
|
|
|
(VOID)StringCchPrintfA(szDeviceInstance,
|
|
40, " (%d)",
|
|
pDeviceInfo->dwInstanceNumber);
|
|
|
|
(VOID)StringCchPrintfW(wszDeviceInstance,
|
|
40, L" (%d)",
|
|
pDeviceInfo->dwInstanceNumber);
|
|
//
|
|
// Append the instance number to the device name
|
|
//
|
|
retcode = StringCchCatA(pDeviceInfo->rdiDeviceInfo.szDeviceName,
|
|
MAX_DEVICE_NAME + 1,
|
|
szDeviceInstance);
|
|
|
|
if(SUCCESS != retcode)
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
retcode = StringCchCatW(pDeviceInfo->rdiDeviceInfo.wszDeviceName,
|
|
MAX_DEVICE_NAME + 1,
|
|
wszDeviceInstance);
|
|
|
|
if(SUCCESS != retcode)
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
RasTapiTrace("New DeviceName=%s",
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName);
|
|
|
|
RasTapiTrace("New WDeviceName=%s",
|
|
pDeviceInfo->rdiDeviceInfo.wszDeviceName);
|
|
|
|
}
|
|
|
|
//
|
|
// Insert the DeviceInfo at the head of the
|
|
// global list
|
|
//
|
|
if ( !fForceRead )
|
|
{
|
|
pDeviceInfo->Next = g_pDeviceInfoList;
|
|
g_pDeviceInfoList = pDeviceInfo;
|
|
|
|
//
|
|
// Trace all this information for this adapter
|
|
//
|
|
TraceEndPointInfo(pDeviceInfo);
|
|
}
|
|
|
|
done:
|
|
|
|
if( (SUCCESS != retcode)
|
|
&& (NULL != pDeviceInfo))
|
|
{
|
|
LocalFree(pDeviceInfo);
|
|
pDeviceInfo = NULL;
|
|
}
|
|
|
|
*ppDeviceInfo = pDeviceInfo;
|
|
|
|
return retcode;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine maps the devicetypes declared in the
|
|
NDIS_WAN_MEDIUM_SUBTYPE enum in ntddndis.h to the
|
|
RASDEVICETYPE enum declared in rasman.h. This
|
|
mapping is done to enable flexibility at the ras
|
|
layer to further categorize the device type into
|
|
paricular classes.
|
|
|
|
Arguments:
|
|
|
|
pDeviceInfo - address of the DeviceInfo structure
|
|
containing the informatio pertaining
|
|
to the device.
|
|
|
|
eMediaType - Device type as defined in ndis for this
|
|
device.
|
|
|
|
|
|
Return Value:
|
|
|
|
Nothing;
|
|
|
|
--*/
|
|
VOID
|
|
MapNdiswanDTtoRasDT(DeviceInfo *pDeviceInfo,
|
|
NDIS_WAN_MEDIUM_SUBTYPE eMediaType)
|
|
{
|
|
RASDEVICETYPE rdt = 0;
|
|
|
|
switch (eMediaType)
|
|
{
|
|
case NdisWanMediumHub:
|
|
{
|
|
rdt = RDT_Other;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumX_25:
|
|
{
|
|
rdt = RDT_X25;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumIsdn:
|
|
{
|
|
rdt = RDT_Isdn;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumSerial:
|
|
{
|
|
rdt = RDT_Serial;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumFrameRelay:
|
|
{
|
|
rdt = RDT_FrameRelay;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumAtm:
|
|
{
|
|
rdt = RDT_Atm;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumSonet:
|
|
{
|
|
rdt = RDT_Sonet;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumSW56K:
|
|
{
|
|
rdt = RDT_Sw56;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumPPTP:
|
|
{
|
|
rdt = RDT_Tunnel_Pptp | RDT_Tunnel;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumL2TP:
|
|
{
|
|
rdt = RDT_Tunnel_L2tp | RDT_Tunnel;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumIrda:
|
|
{
|
|
rdt = RDT_Irda | RDT_Direct;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumParallel:
|
|
{
|
|
rdt = RDT_Parallel | RDT_Direct;
|
|
break;
|
|
}
|
|
|
|
case NdisWanMediumPppoe:
|
|
{
|
|
rdt = RDT_PPPoE | RDT_Broadband;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
rdt = RDT_Other;
|
|
break;
|
|
}
|
|
} // switch
|
|
|
|
pDeviceInfo->rdiDeviceInfo.eDeviceType = rdt;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Checks if a port identified by the line/Address/Call
|
|
is already configured.
|
|
|
|
Arguments:
|
|
|
|
dwLineId - lineID
|
|
|
|
dwAddressID - AddressID
|
|
|
|
dwCallID - CallID
|
|
|
|
ppLine - address to receive the TapiLineInfo to which this
|
|
address/call belongs.
|
|
|
|
Return Value:
|
|
|
|
void
|
|
--*/
|
|
BOOL
|
|
fIsPortAlreadyPresent( DWORD dwlineId,
|
|
DWORD dwAddressId,
|
|
DWORD dwCallId,
|
|
TapiLineInfo** ppLine)
|
|
{
|
|
TapiPortControlBlock *ptpcb = RasPortsList;
|
|
BOOL fPortPresent = FALSE;
|
|
|
|
while(ptpcb)
|
|
{
|
|
if(dwlineId == ptpcb->TPCB_Line->TLI_LineId)
|
|
{
|
|
*ppLine = ptpcb->TPCB_Line;
|
|
|
|
if( PS_UNINITIALIZED != ptpcb->TPCB_State
|
|
&& dwCallId == ptpcb->TPCB_CallId
|
|
&& dwAddressId == ptpcb->TPCB_AddressId
|
|
&& PS_UNAVAILABLE != ptpcb->TPCB_State
|
|
&& (0 ==
|
|
(ptpcb->TPCB_dwFlags & RASTAPI_FLAG_UNAVAILABLE)))
|
|
{
|
|
fPortPresent = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ptpcb = ptpcb->TPCB_next;
|
|
}
|
|
|
|
return fPortPresent;
|
|
}
|
|
|
|
DWORD
|
|
DwLineGetDevCaps(DWORD lineId,
|
|
DWORD NegotiatedApiVersion,
|
|
DWORD NegotiatedExtVersion,
|
|
DWORD dwSize,
|
|
BYTE *pBuffer,
|
|
BYTE **ppBuffer,
|
|
BOOL fUnicode)
|
|
{
|
|
DWORD retcode = SUCCESS;
|
|
|
|
LINEDEVCAPS *pLineDevCaps;
|
|
|
|
ZeroMemory(pBuffer, dwSize);
|
|
|
|
*ppBuffer = pBuffer;
|
|
|
|
pLineDevCaps = (LINEDEVCAPS *) pBuffer;
|
|
pLineDevCaps->dwTotalSize = dwSize;
|
|
|
|
if(!fUnicode)
|
|
{
|
|
retcode = (DWORD)lineGetDevCaps (
|
|
RasLine,
|
|
lineId,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
pLineDevCaps);
|
|
}
|
|
else
|
|
{
|
|
retcode = (DWORD)lineGetDevCapsW(
|
|
RasLine,
|
|
lineId,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
pLineDevCaps);
|
|
}
|
|
|
|
if( (LINEERR_STRUCTURETOOSMALL == retcode)
|
|
|| (pLineDevCaps->dwNeededSize > dwSize))
|
|
{
|
|
DWORD dwNeededSize = pLineDevCaps->dwNeededSize;
|
|
|
|
if(0 == dwNeededSize)
|
|
{
|
|
RasTapiTrace("DwLineGetDevCaps: dwNeededSize == 0!!");
|
|
goto done;
|
|
}
|
|
|
|
*ppBuffer = LocalAlloc(LPTR, pLineDevCaps->dwNeededSize);
|
|
|
|
if(NULL == *ppBuffer)
|
|
{
|
|
retcode = GetLastError();
|
|
}
|
|
else
|
|
{
|
|
pLineDevCaps = (LINEDEVCAPS *) *ppBuffer;
|
|
|
|
pLineDevCaps->dwTotalSize = dwNeededSize;
|
|
|
|
if(!fUnicode)
|
|
{
|
|
retcode = (DWORD)lineGetDevCaps(
|
|
RasLine,
|
|
lineId,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
pLineDevCaps);
|
|
}
|
|
else
|
|
{
|
|
retcode = (DWORD)lineGetDevCapsW(
|
|
RasLine,
|
|
lineId,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
pLineDevCaps);
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
return retcode;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DwLineGetAddrCaps(DWORD lineId,
|
|
DWORD addressId,
|
|
DWORD NegotiatedApiVersion,
|
|
DWORD NegotiatedExtVersion,
|
|
DWORD dwSize,
|
|
BYTE *pBuffer,
|
|
BYTE **ppBuffer)
|
|
{
|
|
|
|
DWORD retcode = SUCCESS;
|
|
|
|
LINEADDRESSCAPS *pAddressCaps;
|
|
|
|
ZeroMemory(pBuffer, dwSize);
|
|
|
|
*ppBuffer = pBuffer;
|
|
|
|
pAddressCaps = (LINEADDRESSCAPS *) pBuffer;
|
|
pAddressCaps->dwTotalSize = dwSize;
|
|
|
|
retcode = (DWORD) lineGetAddressCaps (
|
|
RasLine,
|
|
lineId,
|
|
addressId,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
pAddressCaps);
|
|
|
|
if( (LINEERR_STRUCTURETOOSMALL == retcode)
|
|
|| (pAddressCaps->dwNeededSize > dwSize))
|
|
{
|
|
DWORD dwNeededSize = pAddressCaps->dwNeededSize;
|
|
|
|
if(0 == dwNeededSize)
|
|
{
|
|
RasTapiTrace("DwLineGetAddrCaps: NeededSize==0!!");
|
|
goto done;
|
|
}
|
|
|
|
*ppBuffer = LocalAlloc(LPTR, dwNeededSize);
|
|
if(NULL == *ppBuffer)
|
|
{
|
|
retcode = GetLastError();
|
|
}
|
|
else
|
|
{
|
|
pAddressCaps = (LINEADDRESSCAPS *) *ppBuffer;
|
|
|
|
pAddressCaps->dwTotalSize = dwNeededSize;
|
|
|
|
retcode = (DWORD) lineGetAddressCaps(
|
|
RasLine,
|
|
lineId,
|
|
addressId,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
pAddressCaps);
|
|
}
|
|
}
|
|
|
|
done:
|
|
return retcode;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates RasTapiPorts given the lineID of the newline.
|
|
Returns success without creating ports if ports already
|
|
exist in rastapi corresponding to the line. Iterates
|
|
over all Addresses on a line and all the calls on an
|
|
address to create the ports.
|
|
|
|
Arguments:
|
|
|
|
dwidDevice - ID of the device
|
|
|
|
pcNewPorts [out] - address of the number of new ports
|
|
created. can be NULL.
|
|
|
|
ppptpcbNewPorts [out] - addressreturns an array of
|
|
pointers to newly created
|
|
ports. Cannot be NULL if
|
|
pcNewPorts is not NULL.
|
|
|
|
Return Value:
|
|
|
|
SUCCESS if operation was successful. error otherwise.
|
|
--*/
|
|
|
|
//
|
|
// Temp workaround
|
|
// Work around the alpha compiler bug.
|
|
//
|
|
|
|
#ifdef _ALPHA_
|
|
#pragma function(strcpy)
|
|
#endif
|
|
|
|
DWORD
|
|
dwCreateTapiPortsPerLine(DWORD dwidDevice,
|
|
DWORD *pcNewPorts,
|
|
TapiPortControlBlock ***ppptpcbNewPorts)
|
|
{
|
|
WORD i, k ;
|
|
TapiLineInfo *nextline = NULL;
|
|
// BYTE buffer[800] ;
|
|
LINEADDRESSCAPS *lineaddrcaps ;
|
|
LINEDEVCAPS *linedevcaps ;
|
|
CHAR address[100] ;
|
|
CHAR devicetype[MAX_DEVICETYPE_NAME+1] = {0};
|
|
DWORD devicetypelength;
|
|
CHAR devicename[MAX_DEVICE_NAME+1] = {0};
|
|
DWORD devicenamelength;
|
|
LINEEXTENSIONID extensionid ;
|
|
DWORD totaladdresses ;
|
|
DWORD totalports = 0;
|
|
TapiPortControlBlock *nextport ;
|
|
MSG msg ;
|
|
HINSTANCE hInst;
|
|
TapiPortControlBlock *pports ;
|
|
LINEINITIALIZEEXPARAMS param ;
|
|
DWORD version = HIGH_VERSION ;
|
|
HLINE hLine;
|
|
VARSTRING *pvar;
|
|
BYTE bvar[100];
|
|
LINECALLPARAMS lineparams;
|
|
CHAR szMediaName [MAX_DEVICETYPE_NAME] = {0};
|
|
DWORD dwPortUsage;
|
|
DWORD dwEndPoints;
|
|
DWORD dwRetcode;
|
|
BOOL fModem = FALSE ;
|
|
DWORD retcode = SUCCESS;
|
|
DWORD dwPortIndex;
|
|
DWORD fCreatedINetCfg = FALSE;
|
|
CHAR *pszDeviceType;
|
|
DeviceInfo *pDeviceInfo = NULL;
|
|
BOOL fRasEnabled;
|
|
BOOL fRouterEnabled;
|
|
BOOL fRouterOutboundEnabled = FALSE;
|
|
DWORD NegotiatedApiVersion,
|
|
NegotiatedExtVersion;
|
|
HKEY hkey = NULL;
|
|
BOOL fCharModeSupported = FALSE;
|
|
BOOL fIsValid = FALSE;
|
|
LPBYTE pBuffer = NULL;
|
|
BYTE* pBufferAlloc = NULL;
|
|
|
|
RasTapiTrace( "dwCreateTapiPortsPerLine: line %d...", dwidDevice );
|
|
|
|
pBufferAlloc = LocalAlloc(LPTR, 800);
|
|
if(NULL == pBufferAlloc)
|
|
{
|
|
retcode = E_OUTOFMEMORY;
|
|
goto error;
|
|
}
|
|
|
|
nextport = NULL;
|
|
|
|
if ( pcNewPorts )
|
|
{
|
|
*pcNewPorts = 0;
|
|
}
|
|
|
|
i = ( WORD ) dwidDevice;
|
|
|
|
//
|
|
// for all lines get the addresses -> ports
|
|
//
|
|
if ( retcode = ( DWORD ) lineNegotiateAPIVersion (
|
|
RasLine,
|
|
i,
|
|
LOW_VERSION,
|
|
HIGH_VERSION,
|
|
&NegotiatedApiVersion,
|
|
&extensionid) )
|
|
{
|
|
|
|
RasTapiTrace (
|
|
"dwCreateTapiPortsPerLine: "
|
|
"lineNegotiateAPIVersion() failed. %d",
|
|
retcode );
|
|
|
|
goto error ;
|
|
}
|
|
|
|
if ( lineNegotiateExtVersion( RasLine,
|
|
i,
|
|
NegotiatedApiVersion,
|
|
LOW_EXT_VERSION,
|
|
HIGH_EXT_VERSION,
|
|
&NegotiatedExtVersion))
|
|
{
|
|
NegotiatedExtVersion = 0;
|
|
}
|
|
|
|
if( (NULL != pBuffer)
|
|
&& (pBufferAlloc != pBuffer))
|
|
{
|
|
LocalFree(pBuffer);
|
|
pBuffer = NULL;
|
|
}
|
|
|
|
retcode = DwLineGetDevCaps(
|
|
i,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
800,
|
|
pBufferAlloc,
|
|
&pBuffer,
|
|
FALSE);
|
|
|
|
|
|
if(SUCCESS != retcode)
|
|
{
|
|
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: "
|
|
"lineGetDevCaps Failed. 0x%x",
|
|
retcode );
|
|
|
|
goto error;
|
|
}
|
|
|
|
linedevcaps = (LINEDEVCAPS *) pBuffer;
|
|
|
|
//
|
|
// Figure out if this is a unimodem device or not
|
|
//
|
|
if (NegotiatedApiVersion == HIGH_VERSION)
|
|
{
|
|
//
|
|
// first convert all nulls in the device class
|
|
// string to non nulls.
|
|
//
|
|
DWORD j ;
|
|
char *temp ;
|
|
|
|
for ( j = 0,
|
|
temp = (CHAR *)
|
|
linedevcaps+linedevcaps->dwDeviceClassesOffset;
|
|
j < linedevcaps->dwDeviceClassesSize;
|
|
j++, temp++)
|
|
|
|
if (*temp == '\0')
|
|
*temp = ' ' ;
|
|
|
|
//
|
|
// flag those devices that have comm/datamodem as a
|
|
// device class
|
|
//
|
|
if (strstr( (CHAR *)linedevcaps
|
|
+ linedevcaps->dwDeviceClassesOffset,
|
|
"comm/datamodem") != NULL)
|
|
{
|
|
fModem = TRUE ;
|
|
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: fModem = TRUE");
|
|
|
|
}
|
|
}
|
|
|
|
if (fModem)
|
|
{
|
|
CHAR *pszRegKeyPath;
|
|
|
|
DWORD stringlen = (linedevcaps->dwLineNameSize
|
|
> MAX_DEVICE_NAME - 1
|
|
? MAX_DEVICE_NAME - 1
|
|
: linedevcaps->dwLineNameSize);
|
|
|
|
PRODUCT_TYPE pt = PT_SERVER;
|
|
|
|
strcpy (devicetype, DEVICETYPE_UNIMODEM) ;
|
|
|
|
strncpy ( devicename,
|
|
(CHAR *)linedevcaps
|
|
+ linedevcaps->dwLineNameOffset,
|
|
stringlen) ;
|
|
|
|
devicename[stringlen] = '\0' ;
|
|
|
|
|
|
//
|
|
// Get the AttachedToValue.
|
|
//
|
|
if ( retcode = ( DWORD ) lineOpen (
|
|
RasLine,
|
|
i,
|
|
&hLine,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
0,
|
|
LINECALLPRIVILEGE_NONE,
|
|
LINEMEDIAMODE_DATAMODEM,
|
|
&lineparams))
|
|
{
|
|
RasTapiTrace ("dwCreateTapiPortsPerLine: "
|
|
"lineOpen(%d) Failed. %d",
|
|
i,
|
|
retcode );
|
|
|
|
goto error;
|
|
}
|
|
|
|
pvar = (VARSTRING *) bvar;
|
|
|
|
pvar->dwTotalSize = sizeof (bvar);
|
|
|
|
//
|
|
// Find Out the AttachedTo address
|
|
//
|
|
if ( retcode = ( DWORD ) lineGetID (
|
|
hLine,
|
|
i,
|
|
0,
|
|
LINECALLSELECT_LINE,
|
|
pvar,
|
|
"comm/datamodem/portname"))
|
|
{
|
|
lineClose (hLine);
|
|
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: "
|
|
"lineGetID(%d) failed. %d",
|
|
i,
|
|
retcode );
|
|
goto error;
|
|
}
|
|
|
|
lineClose (hLine);
|
|
|
|
if ( 0 != pvar->dwStringSize
|
|
&& 1 != pvar->dwStringSize)
|
|
{
|
|
strcpy ( address, (CHAR *) pvar + pvar->dwStringOffset );
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: lineGetID(portname) "
|
|
"didn't return a portname for line %d",
|
|
i);
|
|
|
|
retcode = E_FAIL;
|
|
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// Create a device info structure for the modem and
|
|
// insert it in the deviceinfo list
|
|
//
|
|
if(NULL == (pDeviceInfo = GetDeviceInfo((LPBYTE) devicename,
|
|
TRUE)))
|
|
{
|
|
PBYTE pTempBuffer = NULL;
|
|
PBYTE pcaps = NULL;
|
|
|
|
if(NULL == (pDeviceInfo = (DeviceInfo *) LocalAlloc(
|
|
LPTR, sizeof(DeviceInfo))))
|
|
{
|
|
retcode = GetLastError();
|
|
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: Failed"
|
|
" to alloc. %d",
|
|
retcode);
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// Add the device info in the global list maintained
|
|
// and fill in available information
|
|
//
|
|
pDeviceInfo->Next = g_pDeviceInfoList;
|
|
g_pDeviceInfoList = pDeviceInfo;
|
|
|
|
strcpy(
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName,
|
|
devicename);
|
|
|
|
if(linedevcaps->dwBearerModes & LINEBEARERMODE_DATA)
|
|
{
|
|
pDeviceInfo->rdiDeviceInfo.eDeviceType = RDT_Modem
|
|
| RDT_Direct
|
|
| RDT_Null_Modem;
|
|
}
|
|
else
|
|
{
|
|
pDeviceInfo->rdiDeviceInfo.eDeviceType =
|
|
RDT_Modem;
|
|
}
|
|
|
|
//
|
|
// Get the unicode version of the devicename
|
|
//
|
|
pTempBuffer = LocalAlloc(LPTR, 800);
|
|
if(NULL == pTempBuffer)
|
|
{
|
|
retcode = GetLastError();
|
|
RasTapiTrace("Failed to allocate unicode name");
|
|
goto error;
|
|
}
|
|
|
|
retcode = DwLineGetDevCaps(
|
|
i,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
800,
|
|
pTempBuffer,
|
|
&pBuffer,
|
|
TRUE);
|
|
|
|
if(ERROR_SUCCESS == retcode)
|
|
{
|
|
DWORD strLen = (((LINEDEVCAPS *) pBuffer)->dwLineNameSize
|
|
> sizeof(WCHAR) * (MAX_DEVICE_NAME - 1)
|
|
? sizeof(WCHAR) * (MAX_DEVICE_NAME - 1)
|
|
: ((LINEDEVCAPS *) pBuffer)->dwLineNameSize);
|
|
|
|
|
|
CopyMemory((PBYTE) pDeviceInfo->rdiDeviceInfo.wszDeviceName,
|
|
pBuffer +
|
|
((LINEDEVCAPS *)pBuffer)->dwLineNameOffset,
|
|
strLen);
|
|
|
|
pDeviceInfo->rdiDeviceInfo.
|
|
wszDeviceName[strLen/sizeof(WCHAR)] =
|
|
L'\0';
|
|
|
|
RasTapiTrace("ReadModemname=%ws, strlen=%d",
|
|
pDeviceInfo->rdiDeviceInfo.wszDeviceName, strlen);
|
|
}
|
|
|
|
if(NULL != pTempBuffer)
|
|
{
|
|
LocalFree(pTempBuffer);
|
|
}
|
|
|
|
if((pcaps != pTempBuffer) && (NULL != pcaps))
|
|
{
|
|
LocalFree(pcaps);
|
|
}
|
|
}
|
|
|
|
pDeviceInfo->rdiDeviceInfo.dwNumEndPoints = 1;
|
|
|
|
RasTapiTrace("**rdiDeviceInfo.dwNumEndPoints=1");
|
|
|
|
pDeviceInfo->dwCurrentDialedInClients = 0;
|
|
|
|
pDeviceInfo->rdiDeviceInfo.dwMinWanEndPoints
|
|
= pDeviceInfo->rdiDeviceInfo.dwMaxWanEndPoints
|
|
= 1;
|
|
|
|
pDeviceInfo->rdiDeviceInfo.dwTapiLineId = dwidDevice;
|
|
|
|
pDeviceInfo->fValid = TRUE;
|
|
|
|
pszRegKeyPath = ( CHAR *) linedevcaps +
|
|
linedevcaps->dwDevSpecificOffset + 8;
|
|
|
|
if ( retcode = ( DWORD ) RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
pszRegKeyPath,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hkey ) )
|
|
{
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: "
|
|
"failed to open %s. 0x%x",
|
|
pszRegKeyPath,
|
|
retcode );
|
|
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// Per SteveFal, we should not be posting listens on
|
|
// devices by default on workstation. The exception
|
|
// is for NULL modems because WinCE depends on this.
|
|
//
|
|
if(ERROR_SUCCESS != lrGetProductType(&pt))
|
|
{
|
|
RasTapiTrace("Failed to get product type");
|
|
}
|
|
|
|
if( (PT_WORKSTATION == pt)
|
|
&& (0 == (linedevcaps->dwBearerModes & LINEBEARERMODE_DATA)))
|
|
{
|
|
//
|
|
// On a workstation don't listen on modems unless its a NULL
|
|
// modem
|
|
//
|
|
fRasEnabled = FALSE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We enable the devices for dial-in for all other cases
|
|
// if its a server or if its a NULL modem.
|
|
//
|
|
fRasEnabled = TRUE;
|
|
}
|
|
|
|
//
|
|
// Check to see if this device is ras enabled
|
|
//
|
|
retcode = (DWORD) lrIsModemRasEnabled(
|
|
hkey,
|
|
&fRasEnabled,
|
|
&fRouterEnabled);
|
|
|
|
pDeviceInfo->rdiDeviceInfo.fRasEnabled = fRasEnabled;
|
|
|
|
if(!fRasEnabled)
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: device %s is not"
|
|
"enabled for DialIn",
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName);
|
|
}
|
|
|
|
//
|
|
// Get the calledid info for this modem
|
|
//
|
|
retcode = DwGetCalledIdInfo(NULL,
|
|
pDeviceInfo);
|
|
|
|
if(SUCCESS != retcode)
|
|
{
|
|
RasTapiTrace("DwGetCalledIdInfo for %s returned 0x%xd",
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName,
|
|
retcode);
|
|
}
|
|
|
|
pDeviceInfo->rdiDeviceInfo.fRouterEnabled = fRouterEnabled;
|
|
|
|
if(!fRouterEnabled)
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: device %s is not"
|
|
"enabled for routing",
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName);
|
|
}
|
|
|
|
fRouterOutboundEnabled =
|
|
pDeviceInfo->rdiDeviceInfo.fRouterOutboundEnabled = FALSE;
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
//
|
|
// The address that we are returning here is the same
|
|
// for all addresses/calls on this line device. We only
|
|
// need to get it once.
|
|
//
|
|
NDIS_WAN_MEDIUM_SUBTYPE eMediaType;
|
|
|
|
if (retcode = dwGetLineAddress (NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
(LPBYTE) address,
|
|
i,
|
|
0,
|
|
szMediaName,
|
|
&eMediaType))
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: dwGetLineAddrss Failed. %d",
|
|
retcode );
|
|
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// Copy the media name to devicetype
|
|
//
|
|
strncpy(devicetype, szMediaName,MAX_DEVICETYPE_NAME-1);
|
|
|
|
//
|
|
// Get the device information from registry and insert the
|
|
// device info structure in the global list
|
|
//
|
|
if (retcode = GetEndPointInfo(
|
|
&pDeviceInfo,
|
|
address,
|
|
FALSE,
|
|
eMediaType))
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: Failed to get "
|
|
"deviceinformation for %s. %d",
|
|
szMediaName,
|
|
retcode );
|
|
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: Enumerating all "
|
|
"lines/addresses on this adapter");
|
|
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// Fill in the device type for this device
|
|
//
|
|
MapNdiswanDTtoRasDT(pDeviceInfo, eMediaType);
|
|
|
|
//
|
|
// Copy the device name
|
|
//
|
|
strcpy(devicename,
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName);
|
|
|
|
pDeviceInfo->rdiDeviceInfo.dwTapiLineId = dwidDevice;
|
|
|
|
fRasEnabled = pDeviceInfo->rdiDeviceInfo.fRasEnabled;
|
|
|
|
if (!fRasEnabled)
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: Device "
|
|
"%s not enabled for DialIn",
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName);
|
|
}
|
|
|
|
fRouterEnabled = pDeviceInfo->rdiDeviceInfo.fRouterEnabled;
|
|
|
|
if (!fRouterEnabled)
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: Device %s not enabled "
|
|
"for Routing",
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName);
|
|
}
|
|
|
|
fRouterOutboundEnabled =
|
|
pDeviceInfo->rdiDeviceInfo.fRouterOutboundEnabled;
|
|
if(!fRouterOutboundEnabled)
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: Device %s not enabled "
|
|
"for outbound routing",
|
|
pDeviceInfo->rdiDeviceInfo.szDeviceName);
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Get Device Specific information. This is used by
|
|
// the miniport to indicate if it can support character
|
|
// mode
|
|
//
|
|
if (linedevcaps->dwDevSpecificSize
|
|
>= sizeof(RASTAPI_DEV_DATA_MODES))
|
|
{
|
|
PRASTAPI_DEV_DATA_MODES devdatamodes =
|
|
(PRASTAPI_DEV_DATA_MODES)
|
|
((CHAR*)linedevcaps +
|
|
linedevcaps->dwDevSpecificOffset);
|
|
|
|
if ( devdatamodes->MagicCookie == MINIPORT_COOKIE
|
|
&& devdatamodes->DataModes & CHAR_MODE)
|
|
{
|
|
fCharModeSupported = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// A legacy device might not be filling this field. If so
|
|
// give them a single address on their line.
|
|
//
|
|
totaladdresses = (linedevcaps->dwNumAddresses == 0)
|
|
? 1
|
|
: linedevcaps->dwNumAddresses;
|
|
|
|
for (k = 0; k < totaladdresses; k++)
|
|
{
|
|
if( (NULL != pBuffer)
|
|
&& (pBufferAlloc != pBuffer))
|
|
{
|
|
LocalFree(pBuffer);
|
|
pBuffer = NULL;
|
|
}
|
|
|
|
retcode = DwLineGetAddrCaps(
|
|
i,
|
|
k,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
800,
|
|
pBufferAlloc,
|
|
&pBuffer);
|
|
|
|
if(SUCCESS != retcode)
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: lineGetAddresscaps"
|
|
" Failed. 0x%x",
|
|
retcode );
|
|
|
|
goto error ;
|
|
}
|
|
|
|
lineaddrcaps = (LINEADDRESSCAPS *)pBuffer;
|
|
|
|
//
|
|
// Some of the legacy wan miniports might not be filling
|
|
// the NumActiveCalls correctly. They will have at least
|
|
// a single call on each address.
|
|
//
|
|
totalports += (lineaddrcaps->dwMaxNumActiveCalls == 0)
|
|
? 1
|
|
: lineaddrcaps->dwMaxNumActiveCalls;
|
|
|
|
}
|
|
|
|
if ( ppptpcbNewPorts )
|
|
{
|
|
*ppptpcbNewPorts = LocalAlloc (
|
|
LPTR,
|
|
totalports * sizeof (TapiPortControlBlock *));
|
|
|
|
if ( NULL == *ppptpcbNewPorts )
|
|
{
|
|
retcode = ERROR_OUTOFMEMORY;
|
|
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: LocalAlloc Failed. %d",
|
|
retcode );
|
|
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
ASSERT( NULL != pDeviceInfo );
|
|
#endif
|
|
|
|
for (k = 0; k < totaladdresses; k++)
|
|
{
|
|
ULONG totalcalls;
|
|
|
|
if( (NULL != pBuffer)
|
|
&& (pBufferAlloc != pBuffer))
|
|
{
|
|
LocalFree(pBuffer);
|
|
pBuffer = NULL;
|
|
}
|
|
|
|
retcode = DwLineGetAddrCaps(
|
|
i,
|
|
k,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
800,
|
|
pBufferAlloc,
|
|
&pBuffer);
|
|
|
|
if(SUCCESS != retcode)
|
|
{
|
|
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: "
|
|
"lineGetAddressCaps() Failed."
|
|
"0x%x",
|
|
retcode );
|
|
|
|
goto error ;
|
|
}
|
|
|
|
lineaddrcaps = (LINEADDRESSCAPS *) pBuffer;
|
|
|
|
//
|
|
// Some of the legacy wan miniports might not be filling
|
|
// the NumActiveCalls correctly. They will have at least
|
|
// a single call on each address.
|
|
//
|
|
totalcalls = (lineaddrcaps->dwMaxNumActiveCalls == 0)
|
|
? 1
|
|
: lineaddrcaps->dwMaxNumActiveCalls;
|
|
|
|
for ( ; totalcalls ; totalcalls--)
|
|
{
|
|
if (!fModem)
|
|
{
|
|
if ( pDeviceInfo->dwCurrentEndPoints >=
|
|
pDeviceInfo->rdiDeviceInfo.dwNumEndPoints )
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: "
|
|
"CurrentEndPoints=NumEndPoints=%d",
|
|
pDeviceInfo->dwCurrentEndPoints );
|
|
|
|
goto error;
|
|
}
|
|
|
|
dwEndPoints = pDeviceInfo->rdiDeviceInfo.dwNumEndPoints;
|
|
|
|
RasTapiTrace ("dwCreateTapiPortsPerLine: Total = %d",
|
|
dwEndPoints);
|
|
}
|
|
else
|
|
{
|
|
retcode = (DWORD) dwGetPortUsage(&dwPortUsage);
|
|
|
|
if ( retcode )
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: failed to get "
|
|
"modem port usage for %s. 0x%x",
|
|
devicename,
|
|
retcode );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If not rasenabled mask off the callin/router flags
|
|
//
|
|
if(!fRasEnabled)
|
|
{
|
|
dwPortUsage &= ~CALL_IN;
|
|
}
|
|
|
|
if(!fRouterEnabled)
|
|
{
|
|
dwPortUsage &= ~CALL_ROUTER;
|
|
|
|
if(fRouterOutboundEnabled)
|
|
{
|
|
dwPortUsage |= CALL_OUTBOUND_ROUTER;
|
|
}
|
|
}
|
|
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: "
|
|
"PortUsage for %s = %x",
|
|
devicename,
|
|
dwPortUsage);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check to see if we already have this port
|
|
// Also get back the information if we already
|
|
// have the line.
|
|
//
|
|
if(fIsPortAlreadyPresent( i,
|
|
k, totalcalls - 1,
|
|
&nextline))
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: line=%d,address=%d,"
|
|
"call=%d already present",
|
|
i,k, totalcalls - 1);
|
|
|
|
pDeviceInfo->dwCurrentEndPoints += 1;
|
|
|
|
continue;
|
|
}
|
|
|
|
if(nextline)
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: line=%d already present",
|
|
i);
|
|
|
|
nextline->TLI_MultiEndpoint = TRUE;
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace(
|
|
"dwCreateTapiPortsPerLine: Creating line=%d",
|
|
i);
|
|
|
|
nextline = LocalAlloc (LPTR, sizeof ( TapiLineInfo ));
|
|
if ( NULL == nextline )
|
|
{
|
|
retcode = GetLastError();
|
|
|
|
RasTapiTrace (
|
|
"dwCreateTapiPortsPerLine: Failed to allocate"
|
|
" nextline. %d",
|
|
retcode );
|
|
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// Insert the new Line Block into global list
|
|
//
|
|
nextline->TLI_Next = RasTapiLineInfoList;
|
|
RasTapiLineInfoList = nextline;
|
|
nextline->TLI_pDeviceInfo = pDeviceInfo;
|
|
nextline->TLI_LineId = i ;
|
|
nextline->TLI_LineState = PS_CLOSED ;
|
|
nextline->NegotiatedApiVersion = NegotiatedApiVersion;
|
|
nextline->NegotiatedExtVersion = NegotiatedExtVersion;
|
|
nextline->CharModeSupported = fCharModeSupported;
|
|
}
|
|
|
|
//
|
|
// Get a available TPCB from the global pool
|
|
// this will expand the global pool if necessary
|
|
//
|
|
if (NULL == (nextport = GetNextAvailablePort( &dwPortIndex)))
|
|
{
|
|
retcode = ERROR_OUTOFMEMORY;
|
|
|
|
RasTapiTrace (
|
|
"dwCreateTapiPortsPerLine: GetNextAvailablePort "
|
|
"Failed. %d",
|
|
retcode );
|
|
|
|
goto error;
|
|
}
|
|
|
|
if (ppptpcbNewPorts)
|
|
{
|
|
(*ppptpcbNewPorts) [*pcNewPorts] = nextport;
|
|
*pcNewPorts += 1;
|
|
fIsValid = TRUE;
|
|
}
|
|
|
|
pDeviceInfo->dwCurrentEndPoints += 1;
|
|
|
|
//
|
|
// nextport is the TPCB for this address
|
|
//
|
|
nextport->TPCB_Line = nextline ;
|
|
nextport->TPCB_Endpoint = INVALID_HANDLE_VALUE ;
|
|
nextport->TPCB_AddressId = k;
|
|
nextport->TPCB_Signature = CONTROLBLOCKSIGNATURE;
|
|
nextport->TPCB_CallId = totalcalls - 1;
|
|
|
|
//
|
|
// Copy over the devicetype and devicename
|
|
//
|
|
(VOID) StringCchCopyA(nextport->TPCB_DeviceType,
|
|
MAX_DEVICETYPE_NAME,
|
|
devicetype);
|
|
|
|
|
|
//
|
|
// For unimodem devices we need to fix up names
|
|
//
|
|
if (fModem)
|
|
{
|
|
//
|
|
// Device Name is of the form "COM1: Hayes"
|
|
//
|
|
// strcpy (nextport->TPCB_Address, address);
|
|
(VOID) StringCchCopyA(nextport->TPCB_Address,
|
|
MAX_PORT_NAME,
|
|
address);
|
|
|
|
// strcpy (nextport->TPCB_DeviceName, devicename) ;
|
|
(VOID) StringCchCopyA(nextport->TPCB_DeviceName,
|
|
MAX_DEVICE_NAME,
|
|
devicename);
|
|
|
|
//
|
|
// also fix the port name to be the same as address "COM1"
|
|
//
|
|
//strcpy (nextport->TPCB_Name, address) ;
|
|
(VOID) StringCchCopyA(nextport->TPCB_Name,
|
|
MAX_PORT_NAME,
|
|
address);
|
|
|
|
}
|
|
else if(RDT_Parallel == RAS_DEVICE_TYPE(
|
|
pDeviceInfo->rdiDeviceInfo.eDeviceType
|
|
))
|
|
{
|
|
BYTE bDevCaps[800];
|
|
LINEDEVCAPS *pLineDevCaps = NULL;
|
|
|
|
|
|
retcode = DwLineGetDevCaps(
|
|
i,
|
|
NegotiatedApiVersion,
|
|
NegotiatedExtVersion,
|
|
sizeof(bDevCaps),
|
|
bDevCaps,
|
|
(PBYTE *) &pLineDevCaps,
|
|
FALSE);
|
|
|
|
|
|
if(SUCCESS != retcode)
|
|
{
|
|
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: "
|
|
"lineGetDevCaps Failed. 0x%x",
|
|
retcode );
|
|
|
|
goto error;
|
|
}
|
|
|
|
if(pLineDevCaps->dwLineNameSize > 0)
|
|
{
|
|
ZeroMemory(nextport->TPCB_Name,
|
|
MAX_PORT_NAME);
|
|
|
|
memcpy((PBYTE) nextport->TPCB_Name,
|
|
(PBYTE) (((PBYTE) pLineDevCaps) +
|
|
pLineDevCaps->dwLineNameOffset),
|
|
(pLineDevCaps->dwLineNameSize < MAX_PORT_NAME - 1)
|
|
? pLineDevCaps->dwLineNameSize
|
|
: MAX_PORT_NAME - 1);
|
|
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: found %s",
|
|
nextport->TPCB_Name);
|
|
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace("dwCreateTapiPortsPerLine: No name found!!");
|
|
|
|
wsprintf(nextport->TPCB_Name, "%s%d-%d",
|
|
szMediaName,
|
|
pDeviceInfo->dwInstanceNumber,
|
|
pDeviceInfo->dwNextPortNumber);
|
|
|
|
pDeviceInfo->dwNextPortNumber += 1;
|
|
}
|
|
|
|
if(bDevCaps != (PBYTE) pLineDevCaps)
|
|
{
|
|
LocalFree(pLineDevCaps);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wsprintf(nextport->TPCB_Name, "%s%d-%d",
|
|
szMediaName,
|
|
pDeviceInfo->dwInstanceNumber,
|
|
pDeviceInfo->dwNextPortNumber);
|
|
|
|
pDeviceInfo->dwNextPortNumber += 1;
|
|
|
|
}
|
|
|
|
if(!fModem)
|
|
{
|
|
|
|
memcpy (nextport->TPCB_Address, address, sizeof (GUID));
|
|
|
|
if (devicename[0] != '\0')
|
|
{
|
|
// strcpy (nextport->TPCB_DeviceName, devicename) ;
|
|
(VOID) StringCchCopyA(nextport->TPCB_DeviceName,
|
|
MAX_DEVICE_NAME,
|
|
devicename);
|
|
}
|
|
|
|
retcode = dwGetPortUsage(&dwPortUsage);
|
|
|
|
if (retcode)
|
|
{
|
|
RasTapiTrace ("dwCreateTapiPortsPerLine: "
|
|
"GetPortUsage failed. %d",
|
|
retcode );
|
|
}
|
|
else
|
|
{
|
|
if(!fRasEnabled)
|
|
{
|
|
dwPortUsage &= ~CALL_IN;
|
|
}
|
|
|
|
if(!fRouterEnabled)
|
|
{
|
|
dwPortUsage &= ~CALL_ROUTER;
|
|
if(fRouterOutboundEnabled)
|
|
{
|
|
dwPortUsage |= CALL_OUTBOUND_ROUTER;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
//
|
|
// Special Case PPPoE (not really a good thing).
|
|
// Mark the device as CALL_OUT_ONLY if nothing
|
|
// was specified in registry.
|
|
//
|
|
if( (0 == pDeviceInfo->dwUsage)
|
|
&& (RDT_PPPoE == RAS_DEVICE_TYPE(
|
|
pDeviceInfo->rdiDeviceInfo.eDeviceType)))
|
|
{
|
|
pDeviceInfo->dwUsage = CALL_OUT_ONLY;
|
|
}
|
|
|
|
#endif
|
|
|
|
if(CALL_IN_ONLY & pDeviceInfo->dwUsage)
|
|
{
|
|
dwPortUsage &= ~(CALL_OUT | CALL_OUT_ONLY);
|
|
dwPortUsage |= CALL_IN_ONLY;
|
|
}
|
|
else if (CALL_OUT_ONLY & pDeviceInfo->dwUsage)
|
|
{
|
|
dwPortUsage &= ~(CALL_IN | CALL_ROUTER | CALL_IN_ONLY);
|
|
dwPortUsage |= CALL_OUT_ONLY;
|
|
}
|
|
|
|
RasTapiTrace ("dwCreateTapiPortsPerLine:"
|
|
" Friendly Name = %s",
|
|
nextport->TPCB_Name );
|
|
}
|
|
|
|
nextport->TPCB_State = PS_CLOSED ;
|
|
nextport->TPCB_Usage = dwPortUsage;
|
|
|
|
RasTapiTrace ("dwCreateTapiPortsPerLine: "
|
|
"Port Usage for %s = %d",
|
|
nextport->TPCB_Name,
|
|
dwPortUsage );
|
|
|
|
if('\0' == pDeviceInfo->rdiDeviceInfo.szPortName[0])
|
|
{
|
|
strcpy(
|
|
pDeviceInfo->rdiDeviceInfo.szPortName,
|
|
nextport->TPCB_Name);
|
|
}
|
|
|
|
//
|
|
// Initialize overlapped structures.
|
|
//
|
|
nextport->TPCB_ReadOverlapped.RO_EventType =
|
|
OVEVT_DEV_ASYNCOP;
|
|
|
|
nextport->TPCB_WriteOverlapped.RO_EventType =
|
|
OVEVT_DEV_IGNORED;
|
|
|
|
nextport->TPCB_DiscOverlapped.RO_EventType =
|
|
OVEVT_DEV_STATECHANGE;
|
|
} // total calls
|
|
} // total addresses
|
|
|
|
error:
|
|
|
|
if( retcode
|
|
|| !fIsValid)
|
|
{
|
|
if(pcNewPorts)
|
|
{
|
|
*pcNewPorts = 0;
|
|
}
|
|
|
|
if( ppptpcbNewPorts
|
|
&& *ppptpcbNewPorts)
|
|
{
|
|
LocalFree(*ppptpcbNewPorts);
|
|
*ppptpcbNewPorts = NULL;
|
|
}
|
|
}
|
|
|
|
if( (NULL != pBufferAlloc)
|
|
&& (pBufferAlloc != pBuffer))
|
|
{
|
|
LocalFree(pBuffer);
|
|
}
|
|
|
|
LocalFree(pBufferAlloc);
|
|
|
|
RasTapiTrace ("dwGetFriendlyNameAndUsage: done. %d", retcode );
|
|
RasTapiTrace(" ");
|
|
|
|
return retcode;
|
|
}
|
|
|
|
VOID
|
|
InitializeDialInRestriction()
|
|
{
|
|
OSVERSIONINFOEX osvi;
|
|
ULONGLONG ConditionMask;
|
|
|
|
//
|
|
// if its a server and the flavour is not Enterprise (ads) or DataCenter
|
|
// apply the restriction. Note his doesn't take care of various other
|
|
// combinations like embedded/blade, etc.
|
|
//
|
|
|
|
ConditionMask = 0;
|
|
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
|
|
|
|
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
|
|
osvi.wProductType = (USHORT)VER_NT_SERVER;
|
|
|
|
VER_SET_CONDITION(ConditionMask, VER_PRODUCT_TYPE, VER_EQUAL);
|
|
|
|
if(VerifyVersionInfo(&osvi, VER_PRODUCT_TYPE, ConditionMask))
|
|
{
|
|
RasTapiTrace("ProductType is Server");
|
|
|
|
ConditionMask = 0;
|
|
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
|
|
|
|
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
|
|
osvi.wSuiteMask = VER_SUITE_ENTERPRISE
|
|
| VER_SUITE_DATACENTER
|
|
| VER_SUITE_SECURITY_APPLIANCE;
|
|
|
|
VER_SET_CONDITION(ConditionMask, VER_SUITENAME, VER_OR);
|
|
|
|
if(VerifyVersionInfo(&osvi, VER_SUITENAME, ConditionMask))
|
|
{
|
|
RasTapiTrace("Flavour is ads or dtc. No restriction applied");
|
|
g_fRestrictDialIn = FALSE;
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace("Flavour is neither ads nor dtc. Max allowed"
|
|
" dialin=%d", MAX_ALLOWED_DIALIN);
|
|
g_fRestrictDialIn = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace("ProductType is not Server");
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enumerates all lines available in the system and creates
|
|
rastapi ports from each of the lines. Most of the work
|
|
is done by dwCreateTapiPortsPerLine function.
|
|
|
|
Arguments:
|
|
|
|
event - Event handle. This handle is signalled when the
|
|
enumeration is over.
|
|
|
|
Return Value:
|
|
|
|
SUCCESS if operation was successful. error otherwise.
|
|
--*/
|
|
|
|
DWORD
|
|
EnumerateTapiPorts (HANDLE event)
|
|
{
|
|
WORD i ;
|
|
DWORD lines = 0 ;
|
|
MSG msg ;
|
|
HINSTANCE hInst;
|
|
TapiPortControlBlock *pports ;
|
|
LINEINITIALIZEEXPARAMS param ;
|
|
DWORD version = HIGH_VERSION ;
|
|
HKEY hkey = NULL;
|
|
DWORD retcode;
|
|
|
|
|
|
RasTapiTrace("EnumerateTapiPorts");
|
|
|
|
memset (¶m, 0, sizeof (LINEINITIALIZEEXPARAMS)) ;
|
|
|
|
param.dwOptions = LINEINITIALIZEEXOPTION_USEHIDDENWINDOW ;
|
|
param.dwTotalSize = sizeof(param) ;
|
|
|
|
//
|
|
// lineInitialize
|
|
//
|
|
if (lineInitializeEx (&RasLine,
|
|
RasInstance,
|
|
(LINECALLBACK) RasTapiCallback,
|
|
REMOTEACCESS_APP,
|
|
&lines,
|
|
&version,
|
|
¶m))
|
|
{
|
|
|
|
RasTapiTrace( "EnumerateTapiPorts: lineInitializeEx Failed" );
|
|
|
|
goto error ;
|
|
}
|
|
|
|
RasTapiTrace( "EnumerateTapiPorts: Number of lines = %d",
|
|
lines );
|
|
|
|
if (lines == 0)
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
TotalLines = lines;
|
|
|
|
for ( i = 0; i < lines; i++ )
|
|
{
|
|
dwCreateTapiPortsPerLine( i,
|
|
NULL,
|
|
NULL);
|
|
}
|
|
|
|
InitializeDialInRestriction();
|
|
|
|
//
|
|
// Calculate the number of valid ports
|
|
//
|
|
pports = RasPortsList;
|
|
|
|
while ( pports )
|
|
{
|
|
if (pports->TPCB_State != PS_UNINITIALIZED)
|
|
ValidPorts++;
|
|
|
|
pports = pports->TPCB_next;
|
|
}
|
|
|
|
dwGetNumberOfRings( &NumberOfRings );
|
|
|
|
//
|
|
// Increase the reference count on our DLL
|
|
// so it won't get unloaded out from under us.
|
|
//
|
|
hInst = LoadLibrary("rastapi.dll");
|
|
|
|
g_fDllLoaded = TRUE;
|
|
|
|
//
|
|
// Notify the api that the initialization is done
|
|
//
|
|
SetEvent (event) ;
|
|
|
|
//
|
|
// In the pnp world, we need to hang around even if
|
|
// there aren't any ports. ports may be added on the
|
|
// fly
|
|
//
|
|
while ((retcode = GetMessage(&msg, NULL, 0, 0)) &&
|
|
(retcode != -1))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg) ;
|
|
}
|
|
|
|
if(retcode == -1)
|
|
{
|
|
retcode = GetLastError();
|
|
RasTapiTrace("GetMessage failed and returned -1. rc=0x%x",
|
|
retcode);
|
|
}
|
|
|
|
lineShutdown (RasLine) ;
|
|
RasLine = 0;
|
|
|
|
RasTapiTrace("EnumerateTapiPorts done");
|
|
RasTapiTrace(" ");
|
|
TraceDeregister( dwTraceId );
|
|
dwTraceId = INVALID_TRACEID;
|
|
|
|
//
|
|
// The following call atomically unloads our
|
|
// DLL and terminates this thread.
|
|
//
|
|
FreeLibraryAndExitThread(hInst, SUCCESS);
|
|
|
|
error:
|
|
|
|
if (RasLine)
|
|
{
|
|
lineShutdown (RasLine) ;
|
|
}
|
|
|
|
if(INVALID_TRACEID != dwTraceId)
|
|
{
|
|
TraceDeregister( dwTraceId );
|
|
dwTraceId = INVALID_TRACEID;
|
|
}
|
|
|
|
RasLine = 0 ;
|
|
|
|
SetEvent (event) ;
|
|
|
|
|
|
return ((DWORD)-1) ;
|
|
}
|
|
|
|
DWORD
|
|
DwDropIncomingCall(HCALL hcall)
|
|
{
|
|
DWORD RequestID;
|
|
DWORD retcode = ERROR_SUCCESS;
|
|
ZOMBIE_CALL *ZombieCall;
|
|
|
|
ZombieCall = LocalAlloc(LPTR, sizeof(ZOMBIE_CALL));
|
|
|
|
if (ZombieCall == NULL)
|
|
{
|
|
retcode = GetLastError();
|
|
|
|
RasTapiTrace ( "DwDropIncomingCall: Failed to allocate Zombie" );
|
|
goto done;
|
|
}
|
|
|
|
//
|
|
// We will initiate a drop of the call and insert an element on our
|
|
// zombie call list so we can deallocate the call when the drop
|
|
// completes.
|
|
//
|
|
|
|
RequestID = lineDrop(hcall, NULL, 0);
|
|
|
|
if ( RequestID == 0
|
|
|| RequestID > 0x80000000)
|
|
{
|
|
//
|
|
// Either the drop completed sync or there was
|
|
// an error. Either way just deallocate the call.
|
|
//
|
|
lineDeallocateCall(hcall);
|
|
|
|
RasTapiTrace("DwIncomingCall: lineDeallocateCall. RequestID = 0x%x",
|
|
RequestID );
|
|
}
|
|
|
|
ZombieCall->hCall = hcall;
|
|
ZombieCall->RequestID = RequestID;
|
|
InsertHeadList(&ZombieCallList, &ZombieCall->Linkage);
|
|
|
|
done:
|
|
return retcode;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Processes the LINECALLSTATE_OFFERING event.
|
|
|
|
Arguments:
|
|
|
|
hcall - handle of call being offerred
|
|
|
|
ppPort - address of location where the port answering
|
|
the call will be returned.
|
|
|
|
line - the line on which the call was offered.
|
|
|
|
Return Value:
|
|
|
|
SUCCESS if operation was successful. error otherwise.
|
|
--*/
|
|
DWORD
|
|
DwProcessOfferEvent(HCALL hcall,
|
|
TapiPortControlBlock **ppPort,
|
|
TapiLineInfo *line)
|
|
{
|
|
TapiPortControlBlock *port = NULL;
|
|
|
|
LINECALLINFO *linecallinfo;
|
|
|
|
BYTE buffer[1000];
|
|
|
|
BOOL fLimitReached = FALSE;
|
|
|
|
DWORD retcode = SUCCESS;
|
|
|
|
memset (buffer, 0, sizeof(buffer)) ;
|
|
|
|
linecallinfo = (LINECALLINFO *) buffer ;
|
|
|
|
linecallinfo->dwTotalSize = sizeof(buffer) ;
|
|
|
|
RasTapiTrace("DwProcessOfferEvent: hcall=0x%x",
|
|
hcall);
|
|
|
|
//
|
|
// If line get call info fails return.
|
|
//
|
|
if ((retcode = lineGetCallInfo (
|
|
hcall,
|
|
linecallinfo))
|
|
> 0x80000000)
|
|
{
|
|
|
|
RasTapiTrace("DwProcessOfferEvent: LINE_CALLSTATE - "
|
|
"lineGetCallInfo Failed. %d",
|
|
retcode );
|
|
|
|
goto done ;
|
|
}
|
|
|
|
//
|
|
// Find a listening port. First check to see if there are restrictions
|
|
// on the maximum number of dialin ports.
|
|
//
|
|
if ( (g_fRestrictDialIn
|
|
&& g_dwTotalDialIn >= MAX_ALLOWED_DIALIN)
|
|
|| (NULL == (port = FindListeningPort(
|
|
line,
|
|
linecallinfo->dwAddressID))))
|
|
{
|
|
|
|
if(g_dwTotalDialIn >= MAX_ALLOWED_DIALIN)
|
|
{
|
|
RasTapiTrace("DwProcessOfferEvent: Total Dialin clients exceeded"
|
|
" limit. Dropping call 0x%x",
|
|
hcall);
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace("DwProcessOfferEvent: Couldn't find a listening "
|
|
"port. Dropping call 0x%x",
|
|
hcall);
|
|
}
|
|
|
|
(VOID) DwDropIncomingCall(hcall);
|
|
|
|
retcode = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
port->TPCB_CallHandle = hcall ;
|
|
|
|
*ppPort = port;
|
|
|
|
//
|
|
// for unimodem devices wait for the specified
|
|
// number of rings
|
|
//
|
|
if (_stricmp (port->TPCB_DeviceType,
|
|
DEVICETYPE_UNIMODEM) == 0)
|
|
{
|
|
|
|
//
|
|
// call has already been answered by somebody
|
|
// else and is being offered to me
|
|
//
|
|
if (linecallinfo->dwCallStates
|
|
== LINECALLSTATE_CONNECTED)
|
|
{
|
|
|
|
RasTapiTrace ("DwProcessOfferEvent: call already "
|
|
"answered on %s",
|
|
port->TPCB_Name );
|
|
|
|
port->TPCB_ListenState = LS_COMPLETE ;
|
|
|
|
//
|
|
// Complete event so that rasman calls
|
|
// DeviceWork to proceed the listen
|
|
// state machine.
|
|
//
|
|
PostNotificationCompletion(port);
|
|
|
|
}
|
|
else
|
|
{
|
|
if(0 == NumberOfRings)
|
|
{
|
|
port->TPCB_ListenState = LS_ACCEPT;
|
|
|
|
RasTapiTrace( "Accepting call on %s hcall = 0x%x",
|
|
port->TPCB_Name,
|
|
hcall);
|
|
|
|
|
|
port->TPCB_NumberOfRings = 0;
|
|
|
|
PostNotificationCompletion(port);
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace(
|
|
"DwProcessOfferEvent: changing listenstate"
|
|
" of %s from %d to LS_RINGING",
|
|
port->TPCB_Name,
|
|
port->TPCB_ListenState);
|
|
|
|
port->TPCB_ListenState = LS_RINGING ;
|
|
port->TPCB_NumberOfRings = NumberOfRings ;
|
|
|
|
}
|
|
|
|
if(line->TLI_pDeviceInfo)
|
|
{
|
|
line->TLI_pDeviceInfo->dwCurrentDialedInClients += 1;
|
|
}
|
|
|
|
g_dwTotalDialIn += 1;
|
|
|
|
RasTapiTrace( "%s InClients=%d, TotalDialInClients=%d",
|
|
line->TLI_pDeviceInfo->rdiDeviceInfo.szDeviceName,
|
|
line->TLI_pDeviceInfo->dwCurrentDialedInClients,
|
|
g_dwTotalDialIn);
|
|
|
|
port->TPCB_dwFlags |= RASTAPI_FLAG_DIALEDIN;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
//
|
|
// For other devices make transition to
|
|
// next listening state
|
|
//
|
|
port->TPCB_ListenState = LS_ACCEPT ;
|
|
|
|
RasTapiTrace("DwProcessOfferEvent: Accepting call on %s"
|
|
" hcall = 0x%x",
|
|
port->TPCB_Name,
|
|
hcall);
|
|
|
|
if(line->TLI_pDeviceInfo)
|
|
{
|
|
line->TLI_pDeviceInfo->dwCurrentDialedInClients += 1;
|
|
|
|
}
|
|
|
|
g_dwTotalDialIn += 1;
|
|
|
|
RasTapiTrace( "%s InClients=%d, TotalDialInClients=%d",
|
|
line->TLI_pDeviceInfo->rdiDeviceInfo.szDeviceName,
|
|
line->TLI_pDeviceInfo->dwCurrentDialedInClients,
|
|
g_dwTotalDialIn);
|
|
|
|
port->TPCB_dwFlags |= RASTAPI_FLAG_DIALEDIN;
|
|
|
|
//
|
|
// Complete event so that rasman calls DeviceWork
|
|
// to proceed the listen state machine.
|
|
//
|
|
PostNotificationCompletion(port);
|
|
}
|
|
|
|
done:
|
|
|
|
RasTapiTrace("DwProcessOfferEvent 0x%x",
|
|
retcode);
|
|
|
|
return retcode;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
maps LINEDISCONNECTMODE to a raserror so that the proper
|
|
error string can be displayed to the user.
|
|
|
|
Arguments:
|
|
|
|
dm - DisconnectMode
|
|
|
|
Return Value:
|
|
|
|
RasError corresponding to the disconnect mode.
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
DwRasErrorFromDisconnectMode(DWORD dm)
|
|
{
|
|
DWORD dwErr;
|
|
|
|
switch (dm)
|
|
{
|
|
case LINEDISCONNECTMODE_BUSY:
|
|
{
|
|
dwErr = ERROR_LINE_BUSY;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_NOANSWER:
|
|
{
|
|
dwErr = ERROR_NO_ANSWER;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_OUTOFORDER:
|
|
{
|
|
dwErr = ERROR_OUTOFORDER;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_NODIALTONE:
|
|
{
|
|
dwErr = ERROR_NO_DIALTONE;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_CANCELLED:
|
|
{
|
|
dwErr = ERROR_USER_DISCONNECTION;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_UNREACHABLE:
|
|
case LINEDISCONNECTMODE_BADADDRESS:
|
|
{
|
|
dwErr = ERROR_BAD_ADDRESS_SPECIFIED;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_REJECT:
|
|
{
|
|
dwErr = ERROR_CONNECTION_REJECT;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_CONGESTION:
|
|
{
|
|
dwErr = ERROR_CONGESTION;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_INCOMPATIBLE:
|
|
{
|
|
dwErr = ERROR_INCOMPATIBLE;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_NUMBERCHANGED:
|
|
{
|
|
dwErr = ERROR_NUMBERCHANGED;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_TEMPFAILURE:
|
|
{
|
|
dwErr = ERROR_TEMPFAILURE;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_BLOCKED:
|
|
{
|
|
dwErr = ERROR_BLOCKED;
|
|
break;
|
|
}
|
|
|
|
case LINEDISCONNECTMODE_DONOTDISTURB:
|
|
{
|
|
dwErr = ERROR_DONOTDISTURB;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
dwErr = ERROR_FROM_DEVICE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Tapi Call back function as described in win32 sdk.
|
|
|
|
Arguments:
|
|
|
|
win32 sdk has explanation of each of the arguments.
|
|
|
|
Return Value:
|
|
|
|
void
|
|
--*/
|
|
|
|
VOID FAR PASCAL
|
|
RasTapiCallback (HANDLE context,
|
|
DWORD msg,
|
|
ULONG_PTR instance,
|
|
ULONG_PTR param1,
|
|
ULONG_PTR param2,
|
|
ULONG_PTR param3
|
|
)
|
|
{
|
|
LINECALLINFO *linecallinfo ;
|
|
BYTE buffer [1000] ;
|
|
HCALL hcall ;
|
|
HLINE linehandle ;
|
|
TapiLineInfo *line ;
|
|
TapiPortControlBlock *port = NULL;
|
|
DWORD i ;
|
|
DWORD retcode ;
|
|
BOOL fLimitReached = FALSE;
|
|
|
|
// **** Exclusion Begin ****
|
|
GetMutex (RasTapiMutex, INFINITE) ;
|
|
RasTapiTrace("RasTapicallback: msg=%ld , param1=%ul , param2=%ul",msg,param1,param2 );
|
|
|
|
switch (msg)
|
|
{
|
|
|
|
case LINE_CALLSTATE:
|
|
|
|
hcall = (HCALL) HandleToUlong(context) ;
|
|
line = (TapiLineInfo *) instance ;
|
|
|
|
RasTapiTrace("RasTapicallback: linecallstate=0x%x", param1);
|
|
|
|
//
|
|
// If line is closed dont bother
|
|
//
|
|
if (line->TLI_LineState == PS_CLOSED)
|
|
{
|
|
|
|
RasTapiTrace ("RasTapiCallback: LINE_CALLSTATE - "
|
|
"linestate = PS_CLOSED" );
|
|
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// A new call is coming in
|
|
//
|
|
if (param1 == LINECALLSTATE_OFFERING)
|
|
{
|
|
retcode = DwProcessOfferEvent(hcall,
|
|
&port,
|
|
line);
|
|
|
|
if(ERROR_SUCCESS != retcode)
|
|
{
|
|
RasTapiTrace("DwProcessOfferEvent failed. 0x%x",
|
|
retcode);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Find port by call handle
|
|
//
|
|
if ( (NULL == port)
|
|
&& ((port = FindPortByCallHandle(line, hcall)) == NULL)
|
|
&& (LINECALLSTATE_CONNECTED != param1))
|
|
{
|
|
|
|
RasTapiTrace ("RasTapiCallback: FindPortByCallHandle, "
|
|
"hcall = 0x%x failed",
|
|
hcall );
|
|
|
|
break;
|
|
}
|
|
else if ( (NULL == port)
|
|
&& (LINECALLSTATE_CONNECTED == param1))
|
|
{
|
|
RasTapiTrace("Some one else has already answered "
|
|
"the call ");
|
|
|
|
retcode = DwProcessOfferEvent(hcall,
|
|
&port,
|
|
line);
|
|
|
|
if( (ERROR_SUCCESS != retcode)
|
|
|| (NULL == port))
|
|
{
|
|
RasTapiTrace("DwProcessOfferEvent failed. 0x%x",
|
|
retcode);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Call connected.
|
|
//
|
|
if (param1 == LINECALLSTATE_CONNECTED)
|
|
{
|
|
if(NULL == port->TPCB_pConnectInfo)
|
|
{
|
|
memset (buffer, 0, sizeof(buffer)) ;
|
|
|
|
linecallinfo = (LINECALLINFO *) buffer ;
|
|
|
|
linecallinfo->dwTotalSize = sizeof(buffer) ;
|
|
|
|
if ((retcode = lineGetCallInfo (
|
|
hcall,
|
|
linecallinfo))
|
|
> 0x80000000)
|
|
{
|
|
if( (LINEERR_STRUCTURETOOSMALL == retcode)
|
|
|| (linecallinfo->dwNeededSize > sizeof(buffer)))
|
|
{
|
|
DWORD dwSizeNeeded =
|
|
linecallinfo->dwNeededSize;
|
|
|
|
//
|
|
// Allocate the correct size and call
|
|
// the api again
|
|
//
|
|
linecallinfo = LocalAlloc(LPTR,
|
|
dwSizeNeeded);
|
|
|
|
if(NULL == linecallinfo)
|
|
{
|
|
retcode = GetLastError();
|
|
break;
|
|
}
|
|
|
|
linecallinfo->dwTotalSize = dwSizeNeeded;
|
|
|
|
retcode = lineGetCallInfo(
|
|
hcall,
|
|
linecallinfo);
|
|
|
|
}
|
|
}
|
|
|
|
if(retcode > 0x80000000)
|
|
{
|
|
|
|
RasTapiTrace("RasTapiCallback: LINE_CALLSTATE - "
|
|
"lineGetCallInfo Failed. %d",
|
|
retcode );
|
|
|
|
if(buffer != (PBYTE) linecallinfo)
|
|
{
|
|
LocalFree(linecallinfo);
|
|
}
|
|
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// Do the work to get CONNECTINFO, CALLER/CALLEDID
|
|
//
|
|
retcode = DwGetConnectInfo(port,
|
|
hcall,
|
|
linecallinfo);
|
|
|
|
RasTapiTrace("RasTapiCallback: DwGetConnectInfo"
|
|
"returned 0x%x",
|
|
retcode);
|
|
|
|
|
|
//
|
|
// don't want to stop the dial from happening
|
|
// because we couldn't the connect info
|
|
//
|
|
retcode = SUCCESS;
|
|
|
|
//
|
|
// Free the linecallinfo struct. if we allocated
|
|
// it above
|
|
//
|
|
if(buffer != (PBYTE) linecallinfo)
|
|
{
|
|
LocalFree(linecallinfo);
|
|
}
|
|
}
|
|
|
|
RasTapiTrace("RasTapiCallback: Connected on %s",
|
|
port->TPCB_Name);
|
|
|
|
if (port->TPCB_State == PS_CONNECTING)
|
|
{
|
|
|
|
RasTapiTrace("RasTapiCallback: Outgoing call");
|
|
|
|
//
|
|
// We were requesting the call. Complete event
|
|
// so that rasman calls DeviceWork() to complete
|
|
// the connection process.
|
|
//
|
|
PostNotificationCompletion(port);
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This is a call we are asnwering. Now we can
|
|
// indicate to rasman that the call has come in.
|
|
// Setting listen state to LS_COMPLETE may be
|
|
// redundant but handles the case where the answer
|
|
// completes *after* the connection is indicated
|
|
//
|
|
port->TPCB_ListenState = LS_COMPLETE ;
|
|
|
|
RasTapiTrace ("RasTapiCallback: Incoming Call");
|
|
|
|
//
|
|
// Complete event so that rasman knows of
|
|
// incoming call and calls devicework.
|
|
//
|
|
PostNotificationCompletion(port);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Failure of sorts.
|
|
//
|
|
if ( (param1 == LINECALLSTATE_BUSY)
|
|
|| (param1 == LINECALLSTATE_SPECIALINFO))
|
|
{
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: LINECALLSTATE."
|
|
" Failure. param1 = 0x%x",
|
|
param1 );
|
|
|
|
//
|
|
// If we were connecting, notify rasman to call
|
|
// devicework so that the connection attempt can
|
|
// be gracefully failed.
|
|
//
|
|
if (port->TPCB_State == PS_CONNECTING)
|
|
{
|
|
PostNotificationCompletion(port);
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Disconnection happened
|
|
//
|
|
if (param1 == LINECALLSTATE_DISCONNECTED)
|
|
{
|
|
//
|
|
// If we were connecting, notify rasman to call
|
|
// devicework so that the connection attempt can
|
|
// be gracefully failed.
|
|
//
|
|
if (port->TPCB_State == PS_CONNECTING)
|
|
{
|
|
/*
|
|
|
|
if (param2 == LINEDISCONNECTMODE_BUSY)
|
|
{
|
|
port->TPCB_AsyncErrorCode = ERROR_LINE_BUSY ;
|
|
}
|
|
else if ( (param2 == LINEDISCONNECTMODE_NOANSWER)
|
|
|| (param2 == LINEDISCONNECTMODE_OUTOFORDER))
|
|
{
|
|
port->TPCB_AsyncErrorCode = ERROR_NO_ANSWER ;
|
|
}
|
|
else if (param2 == LINEDISCONNECTMODE_NODIALTONE)
|
|
{
|
|
port->TPCB_AsyncErrorCode = ERROR_NO_DIALTONE ;
|
|
}
|
|
else if (param2 == LINEDISCONNECTMODE_CANCELLED)
|
|
{
|
|
port->TPCB_AsyncErrorCode
|
|
= ERROR_USER_DISCONNECTION;
|
|
}
|
|
else if (param2 == LINEDISCONNECTMODE_BADADDRESS)
|
|
{
|
|
port->TPCB_AsyncErrorCode
|
|
= ERROR_BAD_ADDRESS_SPECIFIED;
|
|
}
|
|
|
|
*/
|
|
|
|
port->TPCB_AsyncErrorCode =
|
|
DwRasErrorFromDisconnectMode((DWORD) param2);
|
|
|
|
RasTapiTrace("RasTapiCallback: "
|
|
"LINECALLSTATE_DISCONNECTED "
|
|
"for port %s. AsyncErr = %d, "
|
|
"param2=0x%x",
|
|
port->TPCB_Name,
|
|
port->TPCB_AsyncErrorCode,
|
|
param2);
|
|
|
|
PostNotificationCompletion(port);
|
|
|
|
}
|
|
else if (port->TPCB_State != PS_CLOSED)
|
|
{
|
|
//
|
|
// If we were connected and got a disconnect
|
|
// notification then this could be hardware
|
|
// failure or a remote disconnection. Determine
|
|
// this and save the reason away.
|
|
//
|
|
if (port->TPCB_State == PS_CONNECTED)
|
|
{
|
|
LINECALLSTATUS *pcallstatus ;
|
|
BYTE LineCallStatusBuffer[200] ;
|
|
|
|
memset (LineCallStatusBuffer, 0, sizeof(LineCallStatusBuffer)) ;
|
|
|
|
pcallstatus = (LINECALLSTATUS *) LineCallStatusBuffer ;
|
|
|
|
pcallstatus->dwTotalSize = sizeof (LineCallStatusBuffer) ;
|
|
|
|
lineGetCallStatus (
|
|
port->TPCB_CallHandle,
|
|
pcallstatus) ;
|
|
|
|
if (pcallstatus->dwCallState ==
|
|
LINECALLSTATE_DISCONNECTED)
|
|
{
|
|
port->TPCB_DisconnectReason =
|
|
SS_LINKDROPPED ;
|
|
}
|
|
else
|
|
{
|
|
port->TPCB_DisconnectReason =
|
|
SS_HARDWAREFAILURE ;
|
|
}
|
|
|
|
RasTapiTrace("RasTapiCallback: "
|
|
"lineGetCallStatus"
|
|
" for %s returned 0x%x",
|
|
port->TPCB_Name,
|
|
pcallstatus->dwCallState );
|
|
|
|
RasTapiTrace ("RasTapiCallback: "
|
|
"DisconnectReason "
|
|
"mapped to %d",
|
|
port->TPCB_DisconnectReason);
|
|
|
|
}
|
|
else
|
|
{
|
|
port->TPCB_DisconnectReason = 0 ;
|
|
}
|
|
|
|
//
|
|
// This means that we got a disconnect indication
|
|
// in one of the other states (listening, connected,
|
|
// etc.). We initiate our disconnect state machine.
|
|
//
|
|
RasTapiTrace ("RasTapiCallback: LINECALLSTATE"
|
|
" - initiating Port Disconnect");
|
|
|
|
if (InitiatePortDisconnection (port) != PENDING)
|
|
{
|
|
//
|
|
// Disconnection succeeded or failed. Both
|
|
// are end states for the disconnect state
|
|
// machine so notify rasman that a
|
|
// disconnection has happened.
|
|
//
|
|
RasTapiTrace ("RasTapiCallback: "
|
|
"PortDisconnected sync");
|
|
|
|
PostDisconnectCompletion(port);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// A busy call state - our attempt to dialout failed
|
|
//
|
|
if (param1 == LINECALLSTATE_BUSY)
|
|
{
|
|
|
|
if (port->TPCB_State == PS_CONNECTING)
|
|
{
|
|
|
|
port->TPCB_AsyncErrorCode = ERROR_LINE_BUSY ;
|
|
|
|
RasTapiTrace("RasTapiCallback: Failed to initiate "
|
|
"connection. LINECALLSTATE_BUSY" );
|
|
|
|
PostNotificationCompletion(port);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Idle indication is useful to complete the disconnect
|
|
// state machine.
|
|
//
|
|
if (param1 == LINECALLSTATE_IDLE)
|
|
{
|
|
|
|
if ( ( (port->TPCB_State == PS_DISCONNECTING)
|
|
&& (port->TPCB_RequestId == INFINITE))
|
|
|| ( (port->TPCB_State == PS_OPEN )
|
|
&& (port->TPCB_ListenState == LS_RINGING))
|
|
|| ( (PS_UNAVAILABLE == port->TPCB_State))
|
|
|| ( (port->TPCB_ListenState == LS_RINGING)
|
|
&& (port->TPCB_State == PS_LISTENING)))
|
|
{
|
|
|
|
if ( LS_RINGING == port->TPCB_ListenState )
|
|
{
|
|
RasTapiTrace("RasTapiCallback: Receied IDLE in "
|
|
"LS_RINGING state!" );
|
|
|
|
port->TPCB_DisconnectReason = SS_HARDWAREFAILURE;
|
|
}
|
|
|
|
//
|
|
// IDLE notification came after LineDrop Succeeded
|
|
// so safe to deallocate the call
|
|
//
|
|
if(PS_UNAVAILABLE != port->TPCB_State)
|
|
{
|
|
port->TPCB_State = PS_OPEN ;
|
|
}
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: Received Idle. "
|
|
"Deallocating for %s, callhandle = 0x%x",
|
|
port->TPCB_Name,
|
|
port->TPCB_CallHandle );
|
|
|
|
lineDeallocateCall (port->TPCB_CallHandle) ;
|
|
|
|
port->TPCB_CallHandle = (HCALL) -1 ;
|
|
|
|
port->IdleReceived = FALSE;
|
|
|
|
PostDisconnectCompletion(port);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We have not yet disconnected so do not
|
|
// deallocate call yet. This will be done
|
|
// when the disconnect completes.
|
|
//
|
|
port->IdleReceived = TRUE;
|
|
}
|
|
}
|
|
|
|
break ;
|
|
|
|
|
|
case LINE_REPLY:
|
|
|
|
|
|
RasTapiTrace("LINE_REPLY. param1=0x%x", param1);
|
|
|
|
//
|
|
// This message is sent to indicate completion of an
|
|
// asynchronous API.Find for which port the async request
|
|
// succeeded. This is done by searching for pending
|
|
// request id that is also provided in this message.
|
|
//
|
|
if ((port = FindPortByRequestId ((DWORD) param1)) == NULL)
|
|
{
|
|
ZOMBIE_CALL *ZombieCall =
|
|
(ZOMBIE_CALL*)ZombieCallList.Flink;
|
|
|
|
RasTapiTrace("PortByRequestId found");
|
|
|
|
//
|
|
// If this is the completion of a drop that is
|
|
// in the zombie call state just deallocate
|
|
// the call.
|
|
//
|
|
while ((PLIST_ENTRY)ZombieCall != &ZombieCallList)
|
|
{
|
|
|
|
if (param1 = ZombieCall->RequestID)
|
|
{
|
|
RasTapiTrace (
|
|
"RasTapiCallback: LINE_REPLY "
|
|
"Deallocatingcall. hcall = 0x%x",
|
|
ZombieCall->hCall );
|
|
|
|
lineDeallocateCall(ZombieCall->hCall);
|
|
|
|
RemoveEntryList(&ZombieCall->Linkage);
|
|
|
|
LocalFree(ZombieCall);
|
|
|
|
break;
|
|
}
|
|
|
|
ZombieCall = (ZOMBIE_CALL*)
|
|
ZombieCall->Linkage.Flink;
|
|
}
|
|
|
|
break ;
|
|
}
|
|
else
|
|
;
|
|
|
|
if (port->TPCB_SendRequestId == param1)
|
|
{
|
|
|
|
//
|
|
// A char mode send has completed. Clean up
|
|
// the buffer and notify rasman.
|
|
//
|
|
port->TPCB_SendRequestId = INFINITE;
|
|
|
|
//
|
|
// Free the send desc
|
|
//
|
|
LocalFree(port->TPCB_SendDesc);
|
|
port->TPCB_SendDesc = NULL;
|
|
|
|
|
|
}
|
|
else if (port->TPCB_RecvRequestId == param1)
|
|
{
|
|
|
|
//
|
|
// A char mode recv has completed.
|
|
//
|
|
port->TPCB_RecvRequestId = INFINITE;
|
|
|
|
//
|
|
// If possible notify rasman
|
|
//
|
|
if (port->TPCB_State == PS_CONNECTED)
|
|
{
|
|
//
|
|
// Copy into circular buffer
|
|
//
|
|
CopyDataToFifo(port->TPCB_RecvFifo,
|
|
((PRASTAPI_DEV_SPECIFIC)
|
|
(port->TPCB_RecvDesc))->Data,
|
|
((PRASTAPI_DEV_SPECIFIC)
|
|
(port->TPCB_RecvDesc))->DataSize);
|
|
|
|
}
|
|
|
|
PostNotificationCompletion( port );
|
|
|
|
//
|
|
// Free the recv desc
|
|
//
|
|
LocalFree(port->TPCB_RecvDesc);
|
|
port->TPCB_RecvDesc = NULL;
|
|
}
|
|
else if (port->TPCB_ModeRequestId == param1)
|
|
{
|
|
LocalFree(port->TPCB_ModeRequestDesc);
|
|
port->TPCB_ModeRequestDesc = NULL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Set request id to invalid.
|
|
//
|
|
port->TPCB_RequestId = INFINITE ;
|
|
|
|
if ( (PS_DISCONNECTING == port->TPCB_State)
|
|
|| (PS_UNAVAILABLE == port->TPCB_State))
|
|
{
|
|
//
|
|
// lineDrop completed. Clear the flag that we set to indicate
|
|
// pend of linedrop.
|
|
//
|
|
RasTapiTrace("RasTapiCallback: lineDropped. port %s, id=0x%x",
|
|
port->TPCB_Name,
|
|
port->TPCB_RequestId);
|
|
|
|
port->TPCB_dwFlags &= ~(RASTAPI_FLAG_LINE_DROP_PENDING);
|
|
|
|
//
|
|
// Note that we ignore
|
|
// the return code in param2. This is because
|
|
// we cant do anything else.
|
|
//
|
|
if (port->IdleReceived)
|
|
{
|
|
//
|
|
// We received IDLE notification before/during
|
|
// disconnect so deallocate this call
|
|
//
|
|
port->IdleReceived = FALSE;
|
|
|
|
RasTapiTrace (
|
|
"RasTapiCallback: Idle Received for port %s",
|
|
port->TPCB_Name );
|
|
|
|
if(PS_UNAVAILABLE != port->TPCB_State)
|
|
{
|
|
RasTapiTrace(
|
|
"RasTapiCallback: changing state"
|
|
" of %s. %d -> %d",
|
|
port->TPCB_Name,
|
|
port->TPCB_State,
|
|
PS_OPEN );
|
|
|
|
port->TPCB_State = PS_OPEN ;
|
|
}
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: lineDeallocateCall "
|
|
"for %s,hcall = 0x%x",
|
|
port->TPCB_Name,
|
|
port->TPCB_CallHandle );
|
|
|
|
lineDeallocateCall (port->TPCB_CallHandle) ;
|
|
|
|
port->TPCB_CallHandle = (HCALL) -1 ;
|
|
|
|
|
|
//
|
|
// Check to see if rasman had attempted to listen on
|
|
// this port while linedrop was pending. If so, do a
|
|
// listen on rasmans behalf and return. Don't post a
|
|
// disconnect notification to rasman in this case.
|
|
//
|
|
|
|
if(port->TPCB_dwFlags & RASTAPI_FLAG_LISTEN_PENDING)
|
|
{
|
|
DWORD TempError;
|
|
|
|
RasTapiTrace("RasTapiCallback: Posting listen on"
|
|
" rasman's behalf on port %s",
|
|
port->TPCB_Name);
|
|
|
|
port->TPCB_dwFlags &= ~(RASTAPI_FLAG_LISTEN_PENDING);
|
|
TempError = DeviceListen(port, NULL, NULL);
|
|
RasTapiTrace("DeviceListen returned 0x%x",
|
|
TempError);
|
|
}
|
|
else
|
|
{
|
|
PostDisconnectCompletion(port);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// wait for idle message before signalling
|
|
// disconnect
|
|
//
|
|
;
|
|
}
|
|
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// Some other api completed
|
|
//
|
|
if (param2 == SUCCESS)
|
|
{
|
|
//
|
|
// Success means take no action - unless we are
|
|
// listening in which case it means move to the
|
|
// next state - we simply set the event that will
|
|
// result in a call to DeviceWork() to make the
|
|
// actual call for the next state
|
|
//
|
|
if (port->TPCB_State != PS_LISTENING)
|
|
{
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// Proceed to the next listening sub-state
|
|
//
|
|
if (port->TPCB_ListenState == LS_ACCEPT)
|
|
{
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: LINE_REPLY. Changing "
|
|
"Listen state for %s from %d -> %d",
|
|
port->TPCB_Name,
|
|
port->TPCB_ListenState,
|
|
LS_ANSWER );
|
|
|
|
port->TPCB_ListenState = LS_ANSWER ;
|
|
|
|
PostNotificationCompletion(port);
|
|
}
|
|
else if (port->TPCB_ListenState == LS_ANSWER)
|
|
{
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: LINE_REPLY. Changing "
|
|
"Listen state for %s from %d -> %d",
|
|
port->TPCB_Name,
|
|
port->TPCB_ListenState,
|
|
LS_COMPLETE );
|
|
|
|
port->TPCB_ListenState = LS_COMPLETE ;
|
|
|
|
|
|
//
|
|
// Don't post completion notification in this case.
|
|
// We should post the completion when the connected
|
|
// indication is given. Otherwise we may end up
|
|
// calling lineGetId before it has give a callstate
|
|
// connected to us.
|
|
//
|
|
// PostNotificationCompletion(port);
|
|
RasTapiTrace(
|
|
"**** Not posting completion for lineAnswer ***");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// For connecting and listening ports this means
|
|
// the attempt failed because of some error
|
|
//
|
|
if (port->TPCB_State == PS_CONNECTING)
|
|
{
|
|
{
|
|
if ( LINEERR_INUSE == param2
|
|
|| LINEERR_CALLUNAVAIL == param2)
|
|
{
|
|
//
|
|
// this means that some other tapi
|
|
// device is using this port
|
|
//
|
|
port->TPCB_AsyncErrorCode =
|
|
ERROR_LINE_BUSY;
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: Connect Attempt "
|
|
"on %s failed. 0x%x",
|
|
port->TPCB_Name,
|
|
param2 );
|
|
|
|
|
|
RasTapiTrace (
|
|
"RasTapiCallback: LINE_REPLY. "
|
|
"AsyncErr = %d",
|
|
port->TPCB_AsyncErrorCode );
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
port->TPCB_AsyncErrorCode =
|
|
ERROR_PORT_OR_DEVICE ;
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: ConnectAttempt "
|
|
"on %s failed. 0x%x",
|
|
port->TPCB_Name,
|
|
param2 );
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: LINE_REPLY. "
|
|
"AsyncErr = %d",
|
|
port->TPCB_AsyncErrorCode );
|
|
|
|
}
|
|
|
|
PostNotificationCompletion(port);
|
|
}
|
|
}
|
|
else if (port->TPCB_State == PS_LISTENING)
|
|
{
|
|
//
|
|
// Because ACCEPT may not be supported by
|
|
// the device - treat error as success
|
|
//
|
|
if (port->TPCB_ListenState == LS_ACCEPT)
|
|
{
|
|
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: Changing Listen "
|
|
"State for %s from %d -> %d",
|
|
port->TPCB_Name,
|
|
port->TPCB_ListenState,
|
|
LS_ANSWER );
|
|
|
|
port->TPCB_ListenState = LS_ANSWER ;
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: Changing "
|
|
"Listen State for %s from %d -> %d."
|
|
"param2=0x%x",
|
|
port->TPCB_Name,
|
|
port->TPCB_ListenState,
|
|
LS_ERROR,
|
|
param2);
|
|
|
|
port->TPCB_ListenState = LS_ERROR ;
|
|
}
|
|
|
|
PostNotificationCompletion(port);
|
|
}
|
|
|
|
//
|
|
// Some other API failed, we dont know and
|
|
// we dont care. Ignore.
|
|
//
|
|
else if (port->TPCB_State != PS_CLOSED)
|
|
{
|
|
;
|
|
}
|
|
}
|
|
}
|
|
|
|
break ;
|
|
|
|
case LINE_CLOSE:
|
|
|
|
RasTapiTrace("LINE_CLOSE. line=0x%x", instance);
|
|
|
|
//
|
|
// Typically sent when things go really wrong.
|
|
// Find which line is indication came for.
|
|
//
|
|
line = (TapiLineInfo *) instance ;
|
|
|
|
//
|
|
// if line not found or if it is closed just return
|
|
//
|
|
if ( (line == NULL)
|
|
|| (line->TLI_LineState == PS_CLOSED))
|
|
{
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// For every port that is on the line - open the
|
|
// line again and signal hw failure
|
|
//
|
|
port = RasPortsList;
|
|
|
|
while ( port )
|
|
{
|
|
//
|
|
// Skip ports that arent initialized
|
|
//
|
|
if (port->TPCB_State == PS_UNINITIALIZED)
|
|
{
|
|
port = port->TPCB_next;
|
|
|
|
continue ;
|
|
}
|
|
|
|
//
|
|
// Open the line only if its closed.
|
|
//
|
|
if (port->TPCB_Line == line)
|
|
{
|
|
if(port->TPCB_Line->TLI_LineState != PS_OPEN)
|
|
{
|
|
if (retcode = lineOpen (
|
|
RasLine,
|
|
port->TPCB_Line->TLI_LineId,
|
|
&port->TPCB_Line->TLI_LineHandle,
|
|
port->TPCB_Line->NegotiatedApiVersion,
|
|
port->TPCB_Line->NegotiatedExtVersion,
|
|
(DWORD_PTR) port->TPCB_Line,
|
|
LINECALLPRIVILEGE_OWNER,
|
|
port->TPCB_Line->TLI_MediaMode,
|
|
NULL))
|
|
{
|
|
RasTapiTrace(
|
|
"RasTapiCallback: LINECLOSE:"
|
|
" lineOpen Failed. 0x%x",
|
|
retcode );
|
|
}
|
|
else
|
|
{
|
|
port->TPCB_Line->TLI_LineState = PS_OPEN ;
|
|
RasTapiTrace("RasTapiCallback: Linestate changed from"
|
|
"%d to PS_OPEN",
|
|
port->TPCB_Line->TLI_LineState );
|
|
|
|
}
|
|
|
|
//
|
|
// Set monitoring of rings
|
|
//
|
|
lineSetStatusMessages (
|
|
port->TPCB_Line->TLI_LineHandle,
|
|
LINEDEVSTATE_RINGING, 0) ;
|
|
}
|
|
|
|
if(0 == port->TPCB_AsyncErrorCode)
|
|
{
|
|
port->TPCB_AsyncErrorCode = ERROR_FROM_DEVICE ;
|
|
}
|
|
|
|
port->TPCB_DisconnectReason = SS_HARDWAREFAILURE;
|
|
|
|
port->TPCB_CallHandle = (HCALL) -1 ;
|
|
|
|
port->TPCB_ListenState = LS_ERROR ;
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: LINECLOSE - "
|
|
"Signalling HW Failure for %s",
|
|
port->TPCB_Name );
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: LINECLOSE - "
|
|
"AsyncErr = %d",
|
|
port->TPCB_AsyncErrorCode );
|
|
|
|
PostDisconnectCompletion(port);
|
|
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case LINE_LINEDEVSTATE:
|
|
|
|
RasTapiTrace("LINE_LINEDEVSTATE. param1=0x%x, line=0x%x", param1, instance);
|
|
|
|
//
|
|
// we are only interested in ringing message
|
|
//
|
|
if (param1 != LINEDEVSTATE_RINGING)
|
|
{
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// Find which line is indication came for.
|
|
//
|
|
line = (TapiLineInfo *) instance ;
|
|
|
|
//
|
|
// if line not found or if it is closed
|
|
// just return
|
|
//
|
|
if ( (line == NULL)
|
|
|| (line->TLI_LineState == PS_CLOSED))
|
|
{
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// get the port from the line
|
|
//
|
|
port = RasPortsList;
|
|
while ( port )
|
|
{
|
|
//
|
|
// Skip ports that arent initialized
|
|
//
|
|
if (port->TPCB_State == PS_UNINITIALIZED)
|
|
{
|
|
port = port->TPCB_next;
|
|
continue ;
|
|
}
|
|
|
|
if ( (port->TPCB_Line == line)
|
|
&& (port->TPCB_State == PS_LISTENING)
|
|
&& (port->TPCB_ListenState == LS_RINGING))
|
|
{
|
|
|
|
|
|
if(port->TPCB_NumberOfRings > 0)
|
|
{
|
|
//
|
|
// count down the rings
|
|
//
|
|
port->TPCB_NumberOfRings -= 1 ;
|
|
}
|
|
|
|
RasTapiTrace("RasTapiCallback: LINEDEVSTATE - "
|
|
"Number of rings for %s = %d",
|
|
port->TPCB_Name,
|
|
port->TPCB_NumberOfRings);
|
|
|
|
//
|
|
// if the ring count has gone down to zero
|
|
// this means that we should pick up the call.
|
|
//
|
|
if (port->TPCB_NumberOfRings == 0)
|
|
{
|
|
RasTapiTrace (
|
|
"RasTapiCallback: Changing Listen "
|
|
"State for %s from %d -> %d",
|
|
port->TPCB_Name,
|
|
port->TPCB_ListenState,
|
|
LS_ACCEPT );
|
|
|
|
if(line->TLI_pDeviceInfo)
|
|
{
|
|
line->TLI_pDeviceInfo->dwCurrentDialedInClients
|
|
+= 1;
|
|
|
|
RasTapiTrace(
|
|
"CurrentDialInClients=0x%x",
|
|
line->TLI_pDeviceInfo->dwCurrentDialedInClients);
|
|
}
|
|
|
|
port->TPCB_dwFlags |= RASTAPI_FLAG_DIALEDIN;
|
|
|
|
port->TPCB_ListenState = LS_ACCEPT ;
|
|
|
|
//
|
|
// Complete event so that rasman calls
|
|
// DeviceWork to proceed the listen state
|
|
// machine.
|
|
//
|
|
PostNotificationCompletion(port);
|
|
}
|
|
|
|
break ;
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
}
|
|
|
|
break ;
|
|
|
|
case LINE_CREATE:
|
|
{
|
|
|
|
|
|
DWORD dwError;
|
|
PortMediaInfo *pmiNewDevice = NULL;
|
|
DWORD cNewPorts,
|
|
iNewPort;
|
|
DWORD adwPortsCreated[ LEGACY_MAX ] = {0};
|
|
TapiPortControlBlock *ptpcbPort = NULL,
|
|
**pptpcbNewPorts = NULL;
|
|
//
|
|
// A new device was added. Create a new port
|
|
// and add it to rastapi datastructures
|
|
//
|
|
RasTapiTrace ("RasTapiaCallback: LINE_CREATE");
|
|
|
|
TotalLines++;
|
|
|
|
dwError = dwCreateTapiPortsPerLine(
|
|
(DWORD) param1,
|
|
&cNewPorts,
|
|
&pptpcbNewPorts);
|
|
|
|
if ( dwError )
|
|
{
|
|
|
|
RasTapiTrace ("RasTapiCallback: "
|
|
"dwCreateTapiPortsPerLine "
|
|
"Failed. 0x%x",
|
|
dwError );
|
|
|
|
break;
|
|
}
|
|
|
|
RasTapiTrace ("RasTapiCallback: cNewPorts = %d",
|
|
cNewPorts );
|
|
|
|
for (iNewPort = 0; iNewPort < cNewPorts; iNewPort++)
|
|
{
|
|
ptpcbPort = pptpcbNewPorts [ iNewPort ];
|
|
|
|
//
|
|
// Allocate a PortMediaInfo Structure and fill
|
|
// it with the information about the new device
|
|
// added. This structure will be freed by rasman.
|
|
//
|
|
pmiNewDevice = LocalAlloc (
|
|
LPTR,
|
|
sizeof (PortMediaInfo));
|
|
|
|
if (NULL == pmiNewDevice)
|
|
{
|
|
break;
|
|
}
|
|
|
|
strcpy (pmiNewDevice->PMI_Name, ptpcbPort->TPCB_Name);
|
|
|
|
pmiNewDevice->PMI_Usage = ptpcbPort->TPCB_Usage;
|
|
|
|
strcpy (pmiNewDevice->PMI_DeviceType,
|
|
ptpcbPort->TPCB_DeviceType);
|
|
|
|
strcpy (pmiNewDevice->PMI_DeviceName,
|
|
ptpcbPort->TPCB_DeviceName);
|
|
|
|
pmiNewDevice->PMI_LineDeviceId =
|
|
ptpcbPort->TPCB_Line->TLI_LineId;
|
|
|
|
pmiNewDevice->PMI_AddressId =
|
|
ptpcbPort->TPCB_AddressId;
|
|
|
|
pmiNewDevice->PMI_pDeviceInfo =
|
|
ptpcbPort->TPCB_Line->TLI_pDeviceInfo;
|
|
|
|
RasTapiTrace("RasTapiCallback: New Device Created - %s",
|
|
(ptpcbPort->TPCB_DeviceName
|
|
? ptpcbPort->TPCB_DeviceName
|
|
: "NULL!"));
|
|
|
|
PostNotificationNewPort ( pmiNewDevice );
|
|
}
|
|
|
|
LocalFree ( pptpcbNewPorts );
|
|
|
|
break;
|
|
}
|
|
|
|
case LINE_REMOVE:
|
|
{
|
|
//TapiPortControlBlock *port = RasPortsList;
|
|
|
|
RasTapiTrace ("RasTapiCallback: LINE_REMOVE");
|
|
|
|
PostNotificationRemoveLine((DWORD) param1);
|
|
|
|
/*
|
|
while ( port )
|
|
{
|
|
if ( port->TPCB_Line->TLI_LineId == param1 )
|
|
{
|
|
PostNotificationRemoveLine(param1);
|
|
|
|
RasTapiTrace ("RasTapiCallback: Marking port %s "
|
|
"for removal\n",
|
|
port->TPCB_DeviceName);
|
|
|
|
//
|
|
// Mark the port for removal. The port will be
|
|
// removed when it is closed.
|
|
//
|
|
|
|
RasTapiTrace(
|
|
"RasTapiCallback: Changing state of %s "
|
|
"from %d -> %d",
|
|
port->TPCB_Name,
|
|
port->TPCB_State,
|
|
PS_UNAVAILABLE );
|
|
|
|
port->TPCB_State = PS_UNAVAILABLE ;
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
} */
|
|
|
|
break;
|
|
}
|
|
|
|
case LINE_DEVSPECIFIC:
|
|
{
|
|
|
|
DWORD Status;
|
|
|
|
hcall = (HCALL) HandleToUlong(context) ;
|
|
line = (TapiLineInfo *) instance ;
|
|
|
|
if(NULL == line)
|
|
{
|
|
break;
|
|
}
|
|
|
|
RasTapiTrace("RasTapiCallback:LINE_DEVSPECIFIC");
|
|
|
|
//
|
|
// If line is closed dont bother
|
|
//
|
|
if (line->TLI_LineState == PS_CLOSED)
|
|
{
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// Locate the ras port for this call
|
|
//
|
|
|
|
memset (buffer, 0, sizeof(buffer)) ;
|
|
|
|
linecallinfo = (LINECALLINFO *) buffer ;
|
|
|
|
linecallinfo->dwTotalSize = sizeof(buffer) ;
|
|
|
|
//
|
|
// If line get call info fails return.
|
|
//
|
|
if ((Status = lineGetCallInfo(
|
|
hcall,
|
|
linecallinfo))
|
|
> 0x80000000)
|
|
{
|
|
RasTapiTrace(
|
|
"RastapiCallback: lineGetCallInfo "
|
|
"failed. 0x%x. hcall=0x%x, line=0x%x",
|
|
Status,
|
|
hcall,
|
|
line );
|
|
|
|
break ;
|
|
}
|
|
|
|
//
|
|
// Locate the ras port for this call
|
|
//
|
|
if ((port = FindPortByAddressId (line,
|
|
linecallinfo->dwAddressID)) == NULL)
|
|
{
|
|
|
|
RasTapiTrace("RasTapiCallback: Port not found! "
|
|
"line=0x%x, AddressID=0x%x",
|
|
line,
|
|
linecallinfo->dwAddressID );
|
|
|
|
//
|
|
// Did not find a ras port for the call. Ignore it.
|
|
//
|
|
break ;
|
|
}
|
|
|
|
switch (param1)
|
|
{
|
|
case RASTAPI_DEV_RECV:
|
|
{
|
|
PRASTAPI_DEV_SPECIFIC TapiRecv;
|
|
DWORD TapiRecvSize;
|
|
DWORD requestid;
|
|
|
|
TapiRecvSize = sizeof(RASTAPI_DEV_SPECIFIC) + 1500;
|
|
|
|
if ((TapiRecv = LocalAlloc(
|
|
LPTR, TapiRecvSize)) == NULL)
|
|
{
|
|
RasTapiTrace(
|
|
"RasTapiCallback: RASTAPI_DEV_RECV. "
|
|
"LocalAlloc failed. %d",
|
|
GetLastError() );
|
|
|
|
break;
|
|
}
|
|
|
|
TapiRecv->Command = RASTAPI_DEV_RECV;
|
|
TapiRecv->DataSize = 1500;
|
|
|
|
port->TPCB_RecvDesc = TapiRecv;
|
|
|
|
port->TPCB_RecvRequestId =
|
|
lineDevSpecific(port->TPCB_Line->TLI_LineHandle,
|
|
port->TPCB_AddressId,
|
|
port->TPCB_CallHandle,
|
|
TapiRecv,
|
|
TapiRecvSize);
|
|
|
|
if (port->TPCB_RecvRequestId == 0)
|
|
{
|
|
|
|
//
|
|
// Copy the memory into the circular buffer
|
|
//
|
|
CopyDataToFifo(port->TPCB_RecvFifo,
|
|
TapiRecv->Data,
|
|
TapiRecv->DataSize);
|
|
|
|
port->TPCB_RecvDesc = NULL;
|
|
|
|
LocalFree(TapiRecv);
|
|
|
|
}
|
|
else if (port->TPCB_RecvRequestId > 0x80000000)
|
|
{
|
|
RasTapiTrace(
|
|
"RasTapiCallback: lineDevSpecific "
|
|
"failed. 0x%x",
|
|
port->TPCB_RecvRequestId );
|
|
|
|
port->TPCB_RecvDesc = NULL;
|
|
|
|
port->TPCB_RecvRequestId = INFINITE;
|
|
|
|
LocalFree(TapiRecv);
|
|
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case LINE_ADDRESSSTATE:
|
|
case LINE_CALLINFO:
|
|
case LINE_DEVSPECIFICFEATURE:
|
|
case LINE_GATHERDIGITS:
|
|
case LINE_GENERATE:
|
|
case LINE_MONITORDIGITS:
|
|
case LINE_MONITORMEDIA:
|
|
case LINE_MONITORTONE:
|
|
case LINE_REQUEST:
|
|
default:
|
|
|
|
//
|
|
// All unhandled unsolicited messages.
|
|
//
|
|
;
|
|
}
|
|
|
|
// **** Exclusion End ****
|
|
FreeMutex (RasTapiMutex) ;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find a rastapi port given the AddressID
|
|
|
|
Arguments:
|
|
|
|
line - the lineinfo structure of the line this
|
|
address id one
|
|
|
|
addid - AddressID of the address.
|
|
|
|
Return Value:
|
|
|
|
Pointer to the control block of the port if found.
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
TapiPortControlBlock *
|
|
FindPortByAddressId (TapiLineInfo *line, DWORD addid)
|
|
{
|
|
DWORD i ;
|
|
TapiPortControlBlock *port = RasPortsList;
|
|
|
|
while ( port )
|
|
{
|
|
|
|
if ( (port->TPCB_AddressId == addid)
|
|
&& (port->TPCB_Line == line))
|
|
{
|
|
return port ;
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
}
|
|
|
|
return NULL ;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find a rastapi port given the Address
|
|
|
|
Arguments:
|
|
|
|
address
|
|
|
|
Return Value:
|
|
|
|
Pointer to the control block of the port if found.
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
TapiPortControlBlock *
|
|
FindPortByAddress (CHAR *address)
|
|
{
|
|
DWORD i ;
|
|
TapiPortControlBlock *port = RasPortsList;
|
|
|
|
while ( port )
|
|
{
|
|
|
|
if (_stricmp (port->TPCB_Address,
|
|
address) == 0)
|
|
{
|
|
return port ;
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
}
|
|
|
|
return NULL ;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find a rastapi port given the Address and name
|
|
|
|
Arguments:
|
|
|
|
address
|
|
|
|
name
|
|
|
|
Return Value:
|
|
|
|
Pointer to the control block of the port if found.
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
TapiPortControlBlock *
|
|
FindPortByAddressAndName (CHAR *address, CHAR *name)
|
|
{
|
|
DWORD i ;
|
|
TapiPortControlBlock *port = RasPortsList;
|
|
|
|
while ( port )
|
|
{
|
|
|
|
if ( (_stricmp (
|
|
port->TPCB_Address,
|
|
address) == 0)
|
|
&& (_strnicmp (
|
|
port->TPCB_Name,
|
|
name,
|
|
MAX_PORT_NAME-1) == 0))
|
|
{
|
|
return port ;
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
}
|
|
|
|
return NULL ;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find a rastapi port given the request id
|
|
|
|
Arguments:
|
|
|
|
reqid
|
|
|
|
Return Value:
|
|
|
|
Pointer to the control block of the port if found.
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
TapiPortControlBlock *
|
|
FindPortByRequestId (DWORD reqid)
|
|
{
|
|
DWORD i ;
|
|
TapiPortControlBlock *port = RasPortsList;
|
|
|
|
|
|
while ( port )
|
|
{
|
|
if (port->TPCB_RequestId == reqid)
|
|
{
|
|
return port ;
|
|
}
|
|
else if ( port->TPCB_CharMode )
|
|
{
|
|
if ( port->TPCB_SendRequestId == reqid
|
|
|| port->TPCB_RecvRequestId == reqid
|
|
|| port->TPCB_ModeRequestId == reqid )
|
|
{
|
|
|
|
return port;
|
|
}
|
|
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
}
|
|
|
|
return NULL ;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find a rastapi port given the call handle
|
|
|
|
Arguments:
|
|
|
|
line - line control block of the line on which
|
|
the call was received/made.
|
|
|
|
callhandle
|
|
|
|
Return Value:
|
|
|
|
Pointer to the control block of the port if found.
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
TapiPortControlBlock *
|
|
FindPortByCallHandle(TapiLineInfo *line, HCALL callhandle)
|
|
{
|
|
DWORD i ;
|
|
TapiPortControlBlock *port = RasPortsList;
|
|
|
|
while ( port )
|
|
{
|
|
if ( (port->TPCB_CallHandle == callhandle)
|
|
&& (port->TPCB_Line == line))
|
|
{
|
|
return port ;
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
}
|
|
|
|
return NULL ;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds a port of with the specified addressid
|
|
which is in a listening state
|
|
|
|
Arguments:
|
|
|
|
line - line control block of the line to which this
|
|
address belongs.
|
|
|
|
AddressID
|
|
|
|
Return Value:
|
|
|
|
Pointer to the control block of the port if found.
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
TapiPortControlBlock *
|
|
FindListeningPort(TapiLineInfo *line, DWORD AddressID)
|
|
{
|
|
DWORD i ;
|
|
TapiPortControlBlock *port = RasPortsList;
|
|
|
|
while ( port )
|
|
{
|
|
if ( (port->TPCB_Line == line)
|
|
&& (line->TLI_LineState == PS_LISTENING)
|
|
&& (port->TPCB_State == PS_LISTENING)
|
|
&& (port->TPCB_ListenState == LS_WAIT))
|
|
{
|
|
port->TPCB_AddressId = AddressID;
|
|
return port ;
|
|
}
|
|
|
|
port = port->TPCB_next;
|
|
}
|
|
|
|
return NULL ;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds a line control block of with the specified
|
|
addressid which is in a listening state
|
|
|
|
Arguments:
|
|
|
|
linehandle
|
|
|
|
Return Value:
|
|
|
|
Pointer to the control block of the line if found.
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
TapiLineInfo *
|
|
FindLineByHandle (HLINE linehandle)
|
|
{
|
|
DWORD i ;
|
|
TapiLineInfo *line = RasTapiLineInfoList;
|
|
|
|
while ( line )
|
|
{
|
|
if (line->TLI_LineHandle == linehandle)
|
|
{
|
|
return line ;
|
|
}
|
|
|
|
line = line->TLI_Next;
|
|
}
|
|
|
|
return NULL ;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Posts a disconnect event notification to rasmans
|
|
completion port.
|
|
|
|
Arguments:
|
|
|
|
pointer to the port control block on which the
|
|
disconnect happened.
|
|
|
|
Return Value:
|
|
|
|
void.
|
|
|
|
--*/
|
|
|
|
VOID
|
|
PostDisconnectCompletion(
|
|
TapiPortControlBlock *port
|
|
)
|
|
{
|
|
BOOL fSuccess;
|
|
|
|
if(NULL == port->TPCB_IoCompletionPort)
|
|
{
|
|
RasTapiTrace("PostDisconnectionCompletion: NULL completion port");
|
|
return;
|
|
}
|
|
|
|
|
|
fSuccess = PostQueuedCompletionStatus(
|
|
port->TPCB_IoCompletionPort,
|
|
0,
|
|
port->TPCB_CompletionKey,
|
|
(LPOVERLAPPED)&port->TPCB_DiscOverlapped);
|
|
|
|
if (!fSuccess)
|
|
{
|
|
DWORD dwerror = GetLastError();
|
|
|
|
RasTapiTrace(
|
|
"PostDisconnectCompletion:"
|
|
"PostQueuedCompletionStatus failed. 0x%x",
|
|
dwerror);
|
|
}
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Posts a notification to rasmans completion port
|
|
indicating the completion of an asynchronous
|
|
operation.
|
|
|
|
Arguments:
|
|
|
|
pointer to the port control block on which the
|
|
asynchronous operation completed.
|
|
|
|
Return Value:
|
|
|
|
void.
|
|
|
|
--*/
|
|
|
|
VOID
|
|
PostNotificationCompletion(
|
|
TapiPortControlBlock *port
|
|
)
|
|
{
|
|
BOOL fSuccess;
|
|
|
|
if(NULL == port->TPCB_IoCompletionPort)
|
|
{
|
|
RasTapiTrace("PostNotificationCompletion: NULL completion port");
|
|
return;
|
|
}
|
|
|
|
fSuccess = PostQueuedCompletionStatus(
|
|
port->TPCB_IoCompletionPort,
|
|
0,
|
|
port->TPCB_CompletionKey,
|
|
(LPOVERLAPPED)&port->TPCB_ReadOverlapped);
|
|
|
|
if (!fSuccess)
|
|
{
|
|
DWORD dwerror = GetLastError();
|
|
|
|
RasTapiTrace(
|
|
"PostNotificationCompletion:"
|
|
"PostQueuedCompletionStatus failed. 0x%x",
|
|
dwerror);
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Posts a notification to rasmans completion port
|
|
indicating that a new port was created. For PnP
|
|
|
|
Arguments:
|
|
|
|
pointer to the media control block corresponding
|
|
to the port that was created. Look in
|
|
..\routing\ras\inc\media.h for the definition
|
|
of PortMediaInfo structure.
|
|
|
|
Return Value:
|
|
|
|
void.
|
|
|
|
--*/
|
|
|
|
VOID
|
|
PostNotificationNewPort(
|
|
PortMediaInfo *pmiNewPort
|
|
)
|
|
{
|
|
BOOL fSuccess;
|
|
PRAS_OVERLAPPED pOvNewPortNotification;
|
|
PNEW_PORT_NOTIF pNewPortNotif;
|
|
|
|
RasTapiTrace ("PostNotificationNewPort %s",
|
|
pmiNewPort->PMI_Name );
|
|
|
|
pOvNewPortNotification = LocalAlloc (
|
|
LPTR, sizeof ( RAS_OVERLAPPED));
|
|
|
|
if (NULL == pOvNewPortNotification)
|
|
{
|
|
RasTapiTrace ("PostNotificationNewPort: "
|
|
"Failed to allocate ov.");
|
|
goto done;
|
|
}
|
|
|
|
pNewPortNotif = LocalAlloc (
|
|
LPTR, sizeof (NEW_PORT_NOTIF) );
|
|
|
|
if (NULL == pNewPortNotif)
|
|
{
|
|
RasTapiTrace ("PostNotificationNewPort: Failed "
|
|
"to allocate NEW_PORT_NOTIF");
|
|
LocalFree(pOvNewPortNotification);
|
|
goto done;
|
|
}
|
|
|
|
pNewPortNotif->NPN_pmiNewPort = (PVOID) pmiNewPort;
|
|
|
|
strcpy (
|
|
pNewPortNotif->NPN_MediaName,
|
|
"rastapi");
|
|
|
|
pOvNewPortNotification->RO_EventType = OVEVT_DEV_CREATE;
|
|
pOvNewPortNotification->RO_Info = (PVOID) pNewPortNotif;
|
|
|
|
fSuccess = PostQueuedCompletionStatus(
|
|
g_hIoCompletionPort,
|
|
0,
|
|
0,
|
|
(LPOVERLAPPED) pOvNewPortNotification);
|
|
|
|
if (!fSuccess)
|
|
{
|
|
RasTapiTrace(
|
|
"PostNotificationNewPort: Failed"
|
|
" to Post notification. %d",
|
|
GetLastError());
|
|
|
|
LocalFree(pOvNewPortNotification);
|
|
|
|
LocalFree(pNewPortNotif);
|
|
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace(
|
|
"PostNotificationNewPort: "
|
|
"Posted 0x%x",
|
|
pOvNewPortNotification );
|
|
}
|
|
|
|
done:
|
|
return;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Posts a notification to rasmans completion port
|
|
indicating that a port was removed. For PnP.
|
|
|
|
Arguments:
|
|
|
|
Pointer to the port control block of the port that
|
|
was removed.
|
|
|
|
Return Value:
|
|
|
|
void.
|
|
|
|
--*/
|
|
|
|
VOID
|
|
PostNotificationRemoveLine (
|
|
DWORD dwLineId
|
|
)
|
|
{
|
|
PRAS_OVERLAPPED pOvRemovePortNotification;
|
|
PREMOVE_LINE_NOTIF pRemovePortNotification;
|
|
|
|
pOvRemovePortNotification = LocalAlloc (
|
|
LPTR,
|
|
sizeof (RAS_OVERLAPPED));
|
|
|
|
RasTapiTrace ("PostNotificationRemoveLine: %d",
|
|
dwLineId);
|
|
|
|
if ( NULL == pOvRemovePortNotification )
|
|
{
|
|
RasTapiTrace("PostNotificationRemovePort: "
|
|
"failed to allocate",
|
|
GetLastError());
|
|
goto done;
|
|
}
|
|
|
|
pRemovePortNotification = LocalAlloc(
|
|
LPTR,
|
|
sizeof(REMOVE_LINE_NOTIF));
|
|
|
|
if(NULL == pRemovePortNotification)
|
|
{
|
|
RasTapiTrace("PostNotificationRemovePort: "
|
|
"failed to allocate",
|
|
GetLastError());
|
|
|
|
LocalFree(pOvRemovePortNotification);
|
|
|
|
goto done;
|
|
}
|
|
|
|
pRemovePortNotification->dwLineId = dwLineId;
|
|
|
|
pOvRemovePortNotification->RO_EventType = OVEVT_DEV_REMOVE;
|
|
pOvRemovePortNotification->RO_Info = (PVOID)
|
|
pRemovePortNotification;
|
|
|
|
if ( !PostQueuedCompletionStatus (
|
|
g_hIoCompletionPort,
|
|
0,
|
|
0,
|
|
(LPOVERLAPPED) pOvRemovePortNotification ))
|
|
{
|
|
RasTapiTrace("PostNotificationRemovePort: Failed"
|
|
" to post the notification. %d",
|
|
GetLastError());
|
|
|
|
LocalFree(pOvRemovePortNotification);
|
|
}
|
|
else
|
|
{
|
|
RasTapiTrace("PostNotificationRemovePort:"
|
|
" Posted 0x%x",
|
|
pOvRemovePortNotification );
|
|
}
|
|
|
|
|
|
done:
|
|
return;
|
|
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes a port from the global ports list. For PnP
|
|
|
|
Arguments:
|
|
|
|
Pointer to the port control block of the port that
|
|
is being removed.
|
|
|
|
Return Value:
|
|
|
|
SUCCESS.
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
dwRemovePort ( TapiPortControlBlock * ptpcb )
|
|
{
|
|
|
|
TapiPortControlBlock *pport;
|
|
|
|
GetMutex ( RasTapiMutex, INFINITE );
|
|
|
|
if ( NULL == ptpcb )
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
RasTapiTrace ("dwRemovePort: %s",
|
|
ptpcb->TPCB_Name );
|
|
|
|
if ( RasPortsList == ptpcb )
|
|
{
|
|
RasPortsList = RasPortsList->TPCB_next;
|
|
|
|
LocalFree ( ptpcb );
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
//
|
|
// Remove this port from the global list
|
|
//
|
|
pport = RasPortsList;
|
|
|
|
while (pport->TPCB_next)
|
|
{
|
|
if ( ptpcb == pport->TPCB_next )
|
|
{
|
|
pport->TPCB_next = pport->TPCB_next->TPCB_next;
|
|
|
|
LocalFree (ptpcb);
|
|
|
|
break;
|
|
}
|
|
|
|
pport = pport->TPCB_next;
|
|
}
|
|
|
|
done:
|
|
|
|
FreeMutex ( RasTapiMutex );
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates ports represented by the guid. For PnP
|
|
|
|
Arguments:
|
|
|
|
pbGuidAdapter - Guid of the adapter corresponding
|
|
to the ports that are to be created.
|
|
|
|
pvReserved.
|
|
|
|
Return Value:
|
|
|
|
SUCCESS.
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
dwAddPorts( PBYTE pbGuidAdapter, PVOID pvReserved )
|
|
{
|
|
DWORD retcode = SUCCESS;
|
|
DWORD dwLine;
|
|
DWORD cNewPorts;
|
|
TapiPortControlBlock **pptpcbNewPorts = NULL,
|
|
*ptpcbPort;
|
|
DWORD iNewPort;
|
|
PortMediaInfo *pmiNewDevice = NULL;
|
|
TapiLineInfo *pLineInfo = NULL;
|
|
DeviceInfo *pDeviceInfo = NULL;
|
|
|
|
RasTapiTrace ("dwAddPorts" );
|
|
|
|
pDeviceInfo = GetDeviceInfo (pbGuidAdapter, FALSE);
|
|
|
|
#if DBG
|
|
ASSERT( NULL != pDeviceInfo );
|
|
#endif
|
|
|
|
//
|
|
// Iterate over all the lines to add the new ports
|
|
//
|
|
for ( dwLine = 0; dwLine < TotalLines; dwLine++)
|
|
{
|
|
retcode = dwCreateTapiPortsPerLine( dwLine,
|
|
&cNewPorts,
|
|
&pptpcbNewPorts);
|
|
|
|
if ( retcode
|
|
|| NULL == pptpcbNewPorts)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Added a new pptp port. Fill in the rasman port
|
|
// structure and notify rasman
|
|
//
|
|
for ( iNewPort = 0; iNewPort < cNewPorts; iNewPort++ )
|
|
{
|
|
|
|
ptpcbPort = pptpcbNewPorts [ iNewPort ];
|
|
|
|
//
|
|
// Allocate a PortMediaInfo Structure and fill it
|
|
// with the information about the new device added.
|
|
// This structure will be freed by rasman.
|
|
//
|
|
pmiNewDevice = LocalAlloc (
|
|
LPTR,
|
|
sizeof (PortMediaInfo));
|
|
|
|
if (NULL == pmiNewDevice)
|
|
{
|
|
|
|
RasTapiTrace("dwAddPorts: Failed to allocate "
|
|
"memory. %d",
|
|
GetLastError() );
|
|
|
|
retcode = GetLastError();
|
|
|
|
break;
|
|
}
|
|
|
|
strcpy (
|
|
pmiNewDevice->PMI_Name,
|
|
ptpcbPort->TPCB_Name);
|
|
|
|
pmiNewDevice->PMI_Usage = ptpcbPort->TPCB_Usage;
|
|
|
|
strcpy (
|
|
pmiNewDevice->PMI_DeviceType,
|
|
ptpcbPort->TPCB_DeviceType);
|
|
|
|
strcpy (
|
|
pmiNewDevice->PMI_DeviceName,
|
|
ptpcbPort->TPCB_DeviceName);
|
|
|
|
pmiNewDevice->PMI_LineDeviceId =
|
|
ptpcbPort->TPCB_Line->TLI_LineId;
|
|
|
|
pmiNewDevice->PMI_AddressId =
|
|
ptpcbPort->TPCB_AddressId;
|
|
|
|
pmiNewDevice->PMI_pDeviceInfo = pDeviceInfo;
|
|
|
|
RasTapiTrace ("dwAddPorts: Posting new port "
|
|
"notification for %s",
|
|
ptpcbPort->TPCB_Name);
|
|
|
|
PostNotificationNewPort (pmiNewDevice);
|
|
|
|
}
|
|
|
|
LocalFree ( pptpcbNewPorts );
|
|
|
|
pptpcbNewPorts = NULL;
|
|
|
|
//
|
|
// We already reached the limit. Don't create any
|
|
// more ports
|
|
//
|
|
if (pDeviceInfo->dwCurrentEndPoints ==
|
|
pDeviceInfo->rdiDeviceInfo.dwNumEndPoints)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return retcode;
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copies data from the input buffer to the fifo
|
|
maintained. This is for the devices supporting
|
|
Character Mode.
|
|
|
|
Arguments:
|
|
|
|
Fifo - to which the data has to be copied.
|
|
|
|
Data - data buffer.
|
|
|
|
DataLength - length of the data.
|
|
|
|
Return Value:
|
|
|
|
Number of bytes copied.
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
CopyDataToFifo(
|
|
PRECV_FIFO Fifo,
|
|
PBYTE Data,
|
|
DWORD DataLength
|
|
)
|
|
{
|
|
DWORD bytescopied = 0;
|
|
|
|
while ( Fifo->Count != Fifo->Size
|
|
&& bytescopied < DataLength)
|
|
{
|
|
Fifo->Buffer[Fifo->In++] = Data[bytescopied++];
|
|
Fifo->Count++;
|
|
Fifo->In %= Fifo->Size;
|
|
}
|
|
|
|
return (bytescopied);
|
|
}
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copies data to the buffer from fifo
|
|
This is for the devices supporting
|
|
Character Mode.
|
|
|
|
Arguments:
|
|
|
|
Fifo - to which the data has to be copied.
|
|
|
|
Data - buffer to receive data
|
|
|
|
DataLength - length of the buffer.
|
|
|
|
Return Value:
|
|
|
|
Number of bytes copied.
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
CopyDataFromFifo(
|
|
PRECV_FIFO Fifo,
|
|
PBYTE Buffer,
|
|
DWORD BufferSize
|
|
)
|
|
{
|
|
DWORD bytescopied = 0;
|
|
|
|
while ( bytescopied < BufferSize
|
|
&& Fifo->Count != 0)
|
|
{
|
|
Buffer[bytescopied++] = Fifo->Buffer[Fifo->Out++];
|
|
Fifo->Count--;
|
|
Fifo->Out %= Fifo->Size;
|
|
}
|
|
|
|
return (bytescopied);
|
|
}
|
|
|
|
|
|
|