able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tapi/sp/kmddsp/kmddsp.c

5149 lines
146 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//============================================================================
// Copyright (c) 2000, Microsoft Corporation
//
// File: kmddsp.c
//
// History:
// Dan Knudson (DanKn) 11-Apr-1995 Created
// Yi Sun (YiSun) June-29-2000 Rewriten
//
// Abstract:
//============================================================================
#include "nt.h"
#include "ntrtl.h"
#include "nturtl.h"
#include "windows.h"
#include "rtutils.h"
#include "winioctl.h"
#include "ntddndis.h"
#include "ndistapi.h"
#include "intrface.h"
//
// NOTE: the following are defined in both ndistapi.h & tapi.h (or tspi.h)
// and cause (more or less non-interesting) build warnings, so we
// undefine them after the first #include to do away with this
//
#undef LAST_LINEMEDIAMODE
#undef TSPI_MESSAGE_BASE
#undef LINE_NEWCALL
#undef LINE_CALLDEVSPECIFIC
#undef LINE_CREATE
#include "tapi.h"
#include "tspi.h"
#include "kmddsp.h"
#define OUTBOUND_CALL_KEY ((DWORD) 'OCAL')
#define INBOUND_CALL_KEY ((DWORD) 'ICAL')
#define LINE_KEY ((DWORD) 'KLIN')
#define ASYNCREQWRAPPER_KEY ((DWORD) 'ARWK')
#define INVALID_KEY ((DWORD) 'XXXX')
#define EVENT_BUFFER_SIZE 1024
typedef LONG (*POSTPROCESSPROC)(PASYNC_REQUEST_WRAPPER, LONG, PDWORD_PTR);
typedef struct _ASYNC_REQUEST_WRAPPER
{
// NOTE: overlapped must remain 1st field in this struct
OVERLAPPED Overlapped;
DWORD dwKey;
DWORD dwRequestID;
POSTPROCESSPROC pfnPostProcess;
CRITICAL_SECTION CritSec;
ULONG RefCount;
DWORD_PTR dwRequestSpecific;
// NOTE: NdisTapiRequest must follow a ptr to avoid alignment problem
NDISTAPI_REQUEST NdisTapiRequest;
} ASYNC_REQUEST_WRAPPER, *PASYNC_REQUEST_WRAPPER;
#define REF_ASYNC_REQUEST_WRAPPER(_pAsyncReqWrapper) \
{ \
EnterCriticalSection(&_pAsyncReqWrapper->CritSec); \
_pAsyncReqWrapper->RefCount++; \
LeaveCriticalSection(&_pAsyncReqWrapper->CritSec); \
}
#define DEREF_ASYNC_REQUEST_WRAPPER(_pAsyncReqWrapper) \
{ \
EnterCriticalSection(&_pAsyncReqWrapper->CritSec); \
if (--(_pAsyncReqWrapper->RefCount) == 0) { \
LeaveCriticalSection(&_pAsyncReqWrapper->CritSec); \
DeleteCriticalSection(&_pAsyncReqWrapper->CritSec); \
FreeRequest(_pAsyncReqWrapper); \
_pAsyncReqWrapper = NULL; \
} else { \
LeaveCriticalSection(&_pAsyncReqWrapper->CritSec); \
} \
}
typedef struct _ASYNC_EVENTS_THREAD_INFO
{
HANDLE hThread; // thread handle
PNDISTAPI_EVENT_DATA pBuf; // ptr to a buf for async events
DWORD dwBufSize; // size of the previous buffer
} ASYNC_EVENTS_THREAD_INFO, *PASYNC_EVENTS_THREAD_INFO;
typedef struct _DRVCALL
{
DWORD dwKey;
DWORD dwDeviceID;
HTAPICALL htCall; // TAPI's handle to the call
HDRVCALL hdCall; // TSP's handle to the call
HDRV_CALL hd_Call; // NDISTAPI's call handle
HDRVLINE hdLine; // TSP's handle to the line
union
{
struct _DRVCALL *pPrev; // for inbound calls only
DWORD dwPendingCallState; // for outbound calls only
};
union
{
struct _DRVCALL *pNext; // for inbound calls only
DWORD dwPendingCallStateMode; // for outbound calls only
};
union
{
HTAPI_CALL ht_Call; // for inbound calls only
DWORD dwPendingMediaMode; // for outbound calls only
};
BOOL bIncomplete;
BOOL bDropped;
BOOL bIdle;
} DRVCALL, *PDRVCALL;
typedef struct _DRVLINE
{
DWORD dwKey;
DWORD dwDeviceID;
HTAPILINE htLine; // TAPI's line handle
HDRV_LINE hd_Line; // NDISTAPI's line handle
PDRVCALL pInboundCalls; // inbound call list
// the following two related to PNP/POWER
GUID Guid;
NDIS_WAN_MEDIUM_SUBTYPE MediaType;
} DRVLINE, *PDRVLINE;
// globals
HANDLE ghDriverSync, ghDriverAsync, ghCompletionPort;
PASYNC_EVENTS_THREAD_INFO gpAsyncEventsThreadInfo;
DWORD gdwRequestID;
ASYNC_COMPLETION gpfnCompletionProc;
CRITICAL_SECTION gRequestIDCritSec;
LINEEVENT gpfnLineEvent;
HPROVIDER ghProvider;
//
// debug globals
//
#if DBG
DWORD gdwDebugLevel;
#endif // DBG
DWORD gdwTraceID = INVALID_TRACEID;
//
// creates a log using the RAS tracing utility
// also prints it onto the attached debugger
// if a debug build is running
//
VOID
TspLog(
IN DWORD dwDebugLevel,
IN PCHAR pchFormat,
...
)
{
va_list arglist;
CHAR chNewFmt[256];
va_start(arglist, pchFormat);
switch (dwDebugLevel)
{
case DL_ERROR:
strcpy(chNewFmt, "!!! ");
break;
case DL_WARNING:
strcpy(chNewFmt, "!! ");
break;
case DL_INFO:
strcpy(chNewFmt, "! ");
break;
case DL_TRACE:
strcpy(chNewFmt, " ");
break;
}
strcat(chNewFmt, pchFormat);
#if DBG
if (dwDebugLevel <= gdwDebugLevel)
{
#if 0
DbgPrint("++KMDDSP++ ");
DbgPrint(chNewFmt, arglist);
DbgPrint("\n");
#else
char szBuffer[256];
OutputDebugString("++KMDDSP++ ");
wvsprintf(szBuffer, chNewFmt, arglist);
OutputDebugString(szBuffer);
OutputDebugString("\n");
#endif
}
#endif // DBG
if (gdwTraceID != INVALID_TRACEID)
{
TraceVprintfEx(gdwTraceID,
(dwDebugLevel << 16) | TRACE_USE_MASK | TRACE_USE_MSEC,
chNewFmt,
arglist);
}
va_end(arglist);
#if DBG
if (DL_ERROR == dwDebugLevel)
{
//DebugBreak();
}
#endif // DBG
}
#if DBG
#define INSERTVARDATASTRING(a,b,c,d,e,f) InsertVarDataString(a,b,c,d,e,f)
void
PASCAL
InsertVarDataString(
LPVOID pStruct,
LPDWORD pdwXxxSize,
LPVOID pNewStruct,
LPDWORD pdwNewXxxSize,
DWORD dwFixedStructSize,
char *pszFieldName
)
#else
#define INSERTVARDATASTRING(a,b,c,d,e,f) InsertVarDataString(a,b,c,d,e)
void
PASCAL
InsertVarDataString(
LPVOID pStruct,
LPDWORD pdwXxxSize,
LPVOID pNewStruct,
LPDWORD pdwNewXxxSize,
DWORD dwFixedStructSize
)
#endif
{
DWORD dwXxxSize, dwTotalSize, dwXxxOffset;
//
// If the dwXxxSize field of the old struct is non-zero, then
// we need to do a ascii->unicode conversion on it. Check to
// make sure that the size/offset are valid (if not set the
// data size/offset in the new struct to 0) and then convert.
//
if ((dwXxxSize = *pdwXxxSize))
{
dwXxxOffset = *(pdwXxxSize + 1);
#if DBG
dwTotalSize = ((LPVARSTRING) pStruct)->dwTotalSize;
if (dwXxxSize > (dwTotalSize - dwFixedStructSize) ||
dwXxxOffset < dwFixedStructSize ||
dwXxxOffset >= dwTotalSize ||
(dwXxxSize + dwXxxOffset) > dwTotalSize)
{
TspLog(DL_ERROR,
"INSERTVARDATASTRING: bad %s values - size(x%x), "\
"offset(x%x)",
pszFieldName, dwXxxSize, dwXxxOffset);
*pdwNewXxxSize = *(pdwNewXxxSize + 1) = 0;
return;
}
#endif
// make sure the string is NULL terminated
*(((LPBYTE)pStruct) + (dwXxxOffset + dwXxxSize - 1)) = '\0';
MultiByteToWideChar(
CP_ACP,
MB_PRECOMPOSED,
((LPBYTE) pStruct) + dwXxxOffset,
dwXxxSize,
(LPWSTR) (((LPBYTE) pNewStruct) +
((LPVARSTRING) pNewStruct)->dwUsedSize),
dwXxxSize * sizeof (WCHAR)
);
*pdwNewXxxSize = dwXxxSize * sizeof (WCHAR);
*(pdwNewXxxSize + 1) = ((LPVARSTRING) pNewStruct)->dwUsedSize; // offset
((LPVARSTRING) pNewStruct)->dwUsedSize += (dwXxxSize * sizeof (WCHAR));
}
}
#if DBG
#define INSERTVARDATA(a,b,c,d,e,f) InsertVarData(a,b,c,d,e,f)
void
PASCAL
InsertVarData(
LPVOID pStruct,
LPDWORD pdwXxxSize,
LPVOID pNewStruct,
LPDWORD pdwNewXxxSize,
DWORD dwFixedStructSize,
char *pszFieldName
)
#else
#define INSERTVARDATA(a,b,c,d,e,f) InsertVarData(a,b,c,d,e)
void
PASCAL
InsertVarData(
LPVOID pStruct,
LPDWORD pdwXxxSize,
LPVOID pNewStruct,
LPDWORD pdwNewXxxSize,
DWORD dwFixedStructSize
)
#endif
{
DWORD dwTotalSize, dwXxxSize, dwXxxOffset;
if ((dwXxxSize = *pdwXxxSize))
{
dwXxxOffset = *(pdwXxxSize + 1);
#if DBG
dwTotalSize = ((LPVARSTRING) pStruct)->dwTotalSize;
if (dwXxxSize > (dwTotalSize - dwFixedStructSize) ||
dwXxxOffset < dwFixedStructSize ||
dwXxxOffset >= dwTotalSize ||
(dwXxxSize + dwXxxOffset) > dwTotalSize)
{
TspLog(DL_ERROR,
"INSERTVARDATA: bad %s values - size(x%x), offset(x%x)",
pszFieldName, dwXxxSize, dwXxxOffset);
*pdwNewXxxSize = *(pdwNewXxxSize + 1) = 0;
return;
}
#endif
CopyMemory(
((LPBYTE) pNewStruct) + ((LPVARSTRING) pNewStruct)->dwUsedSize,
((LPBYTE) pStruct) + dwXxxOffset,
dwXxxSize
);
*pdwNewXxxSize = dwXxxSize;
*(pdwNewXxxSize + 1) = ((LPVARSTRING) pNewStruct)->dwUsedSize; // offset
((LPVARSTRING) pNewStruct)->dwUsedSize += dwXxxSize;
}
}
static char *pszOidNames[] =
{
"Accept",
"Answer",
"Close",
"CloseCall",
"ConditionalMediaDetection",
"ConfigDialog",
"DevSpecific",
"Dial",
"Drop",
"GetAddressCaps",
"GetAddressID",
"GetAddressStatus",
"GetCallAddressID",
"GetCallInfo",
"GetCallStatus",
"GetDevCaps",
"GetDevConfig",
"GetExtensionID",
"GetID",
"GetLineDevStatus",
"MakeCall",
"NegotiateExtVersion",
"Open",
"ProviderInitialize",
"ProviderShutdown",
"SecureCall",
"SelectExtVersion",
"SendUserUserInfo",
"SetAppSpecific",
"StCallParams",
"StDefaultMediaDetection",
"SetDevConfig",
"SetMediaMode",
"SetStatusMessages"
};
//
// translates NDIS TAPI status codes into LINEERR_XXX
//
LONG
WINAPI
TranslateDriverResult(
ULONG ulRes
)
{
typedef struct _RESULT_LOOKUP
{
ULONG NdisTapiResult;
LONG TapiResult;
} RESULT_LOOKUP, *PRESULT_LOOKUP;
typedef ULONG NDIS_STATUS;
#define NDIS_STATUS_SUCCESS 0x00000000L
#define NDIS_STATUS_RESOURCES 0xC000009AL
#define NDIS_STATUS_FAILURE 0xC0000001L
#define NDIS_STATUS_INVALID_OID 0xC0010017L
static RESULT_LOOKUP aResults[] =
{
//
// Defined in NDIS.H
//
{ NDIS_STATUS_SUCCESS ,0 },
//
// These errors are defined in NDISTAPI.H
//
{ NDIS_STATUS_TAPI_ADDRESSBLOCKED ,LINEERR_ADDRESSBLOCKED },
{ NDIS_STATUS_TAPI_BEARERMODEUNAVAIL ,LINEERR_BEARERMODEUNAVAIL },
{ NDIS_STATUS_TAPI_CALLUNAVAIL ,LINEERR_CALLUNAVAIL },
{ NDIS_STATUS_TAPI_DIALBILLING ,LINEERR_DIALBILLING },
{ NDIS_STATUS_TAPI_DIALDIALTONE ,LINEERR_DIALDIALTONE },
{ NDIS_STATUS_TAPI_DIALPROMPT ,LINEERR_DIALPROMPT },
{ NDIS_STATUS_TAPI_DIALQUIET ,LINEERR_DIALQUIET },
{ NDIS_STATUS_TAPI_INCOMPATIBLEEXTVERSION,LINEERR_INCOMPATIBLEEXTVERSION},
{ NDIS_STATUS_TAPI_INUSE ,LINEERR_INUSE },
{ NDIS_STATUS_TAPI_INVALADDRESS ,LINEERR_INVALADDRESS },
{ NDIS_STATUS_TAPI_INVALADDRESSID ,LINEERR_INVALADDRESSID },
{ NDIS_STATUS_TAPI_INVALADDRESSMODE ,LINEERR_INVALADDRESSMODE },
{ NDIS_STATUS_TAPI_INVALBEARERMODE ,LINEERR_INVALBEARERMODE },
{ NDIS_STATUS_TAPI_INVALCALLHANDLE ,LINEERR_INVALCALLHANDLE },
{ NDIS_STATUS_TAPI_INVALCALLPARAMS ,LINEERR_INVALCALLPARAMS },
{ NDIS_STATUS_TAPI_INVALCALLSTATE ,LINEERR_INVALCALLSTATE },
{ NDIS_STATUS_TAPI_INVALDEVICECLASS ,LINEERR_INVALDEVICECLASS },
{ NDIS_STATUS_TAPI_INVALLINEHANDLE ,LINEERR_INVALLINEHANDLE },
{ NDIS_STATUS_TAPI_INVALLINESTATE ,LINEERR_INVALLINESTATE },
{ NDIS_STATUS_TAPI_INVALMEDIAMODE ,LINEERR_INVALMEDIAMODE },
{ NDIS_STATUS_TAPI_INVALRATE ,LINEERR_INVALRATE },
{ NDIS_STATUS_TAPI_NODRIVER ,LINEERR_NODRIVER },
{ NDIS_STATUS_TAPI_OPERATIONUNAVAIL ,LINEERR_OPERATIONUNAVAIL },
{ NDIS_STATUS_TAPI_RATEUNAVAIL ,LINEERR_RATEUNAVAIL },
{ NDIS_STATUS_TAPI_RESOURCEUNAVAIL ,LINEERR_RESOURCEUNAVAIL },
{ NDIS_STATUS_TAPI_STRUCTURETOOSMALL ,LINEERR_STRUCTURETOOSMALL },
{ NDIS_STATUS_TAPI_USERUSERINFOTOOBIG ,LINEERR_USERUSERINFOTOOBIG },
{ NDIS_STATUS_TAPI_ALLOCATED ,LINEERR_ALLOCATED },
{ NDIS_STATUS_TAPI_INVALADDRESSSTATE ,LINEERR_INVALADDRESSSTATE },
{ NDIS_STATUS_TAPI_INVALPARAM ,LINEERR_INVALPARAM },
{ NDIS_STATUS_TAPI_NODEVICE ,LINEERR_NODEVICE },
//
// These errors are defined in NDIS.H
//
{ NDIS_STATUS_RESOURCES ,LINEERR_NOMEM },
{ NDIS_STATUS_FAILURE ,LINEERR_OPERATIONFAILED },
{ NDIS_STATUS_INVALID_OID ,LINEERR_OPERATIONFAILED },
//
//
//
{ NDISTAPIERR_UNINITIALIZED ,LINEERR_OPERATIONFAILED },
{ NDISTAPIERR_BADDEVICEID ,LINEERR_OPERATIONFAILED },
{ NDISTAPIERR_DEVICEOFFLINE ,LINEERR_OPERATIONFAILED },
//
// The terminating fields
//
{ 0xffffffff, 0xffffffff }
};
int i;
for (i = 0; aResults[i].NdisTapiResult != 0xffffffff; i++)
{
if (ulRes == aResults[i].NdisTapiResult)
{
return (aResults[i].TapiResult);
}
}
TspLog(DL_WARNING, "TranslateDriverResult: unknown driver result(%x)",
ulRes);
return LINEERR_OPERATIONFAILED;
}
//
// NOTE: for functions that need to acquire (read, write) locks for both
// a line and a call, we enforce the order to be line first, call
// second to avoid potential DEADLOCK.
//
LONG
GetLineObjWithReadLock(
IN HDRVLINE hdLine,
OUT PDRVLINE *ppLine
)
{
LONG lRes;
PDRVLINE pLine;
lRes = GetObjWithReadLock((HANDLE)hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return LINEERR_INVALLINEHANDLE;
}
ASSERT(pLine != NULL);
if (pLine->dwKey != LINE_KEY)
{
TspLog(DL_WARNING, "GetLineObjWithReadLock: obj(%p) has bad key(%x)",
hdLine, pLine->dwKey);
ReleaseObjReadLock((HANDLE)hdLine);
return LINEERR_INVALLINEHANDLE;
}
*ppLine = pLine;
return lRes;
}
LONG
GetLineObjWithWriteLock(
IN HDRVLINE hdLine,
OUT PDRVLINE *ppLine
)
{
LONG lRes;
PDRVLINE pLine;
lRes = GetObjWithWriteLock((HANDLE)hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return LINEERR_INVALLINEHANDLE;
}
ASSERT(pLine != NULL);
if (pLine->dwKey != LINE_KEY)
{
TspLog(DL_WARNING, "GetLineObjWithWriteLock: obj(%p) has bad key(%x)",
hdLine, pLine->dwKey);
ReleaseObjWriteLock((HANDLE)hdLine);
return LINEERR_INVALLINEHANDLE;
}
*ppLine = pLine;
return lRes;
}
LONG
GetCallObjWithReadLock(
IN HDRVCALL hdCall,
OUT PDRVCALL *ppCall
)
{
LONG lRes;
PDRVCALL pCall;
lRes = GetObjWithReadLock((HANDLE)hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return LINEERR_INVALCALLHANDLE;
}
ASSERT(pCall != NULL);
if (pCall->dwKey != INBOUND_CALL_KEY &&
pCall->dwKey != OUTBOUND_CALL_KEY)
{
TspLog(DL_WARNING, "GetCallObjWithReadLock: obj(%p) has bad key(%x)",
hdCall, pCall->dwKey);
ReleaseObjReadLock((HANDLE)hdCall);
return LINEERR_INVALCALLHANDLE;
}
*ppCall = pCall;
return lRes;
}
LONG
GetCallObjWithWriteLock(
IN HDRVCALL hdCall,
OUT PDRVCALL *ppCall
)
{
LONG lRes;
PDRVCALL pCall;
lRes = GetObjWithWriteLock((HANDLE)hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return LINEERR_INVALCALLHANDLE;
}
ASSERT(pCall != NULL);
if (pCall->dwKey != INBOUND_CALL_KEY &&
pCall->dwKey != OUTBOUND_CALL_KEY)
{
TspLog(DL_WARNING, "GetCallObjWithWriteLock: obj(%p) has bad key(%x)",
hdCall, pCall->dwKey);
ReleaseObjWriteLock((HANDLE)hdCall);
return LINEERR_INVALCALLHANDLE;
}
*ppCall = pCall;
return lRes;
}
LONG
GetLineHandleFromCallHandle(
IN HDRVCALL hdCall,
OUT HDRVLINE *phdLine
)
{
LONG lRes;
PDRVCALL pCall;
lRes = GetObjWithReadLock((HANDLE)hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return LINEERR_INVALCALLHANDLE;
}
ASSERT(pCall != NULL);
if (pCall->dwKey != INBOUND_CALL_KEY &&
pCall->dwKey != OUTBOUND_CALL_KEY)
{
TspLog(DL_WARNING,
"GetLineHandleFromCallHandle: obj(%p) has bad key(%x)",
hdCall, pCall->dwKey);
ReleaseObjReadLock((HANDLE)hdCall);
return LINEERR_INVALCALLHANDLE;
}
*phdLine = pCall->hdLine;
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
GetLineAndCallObjWithReadLock(
HTAPI_LINE ht_Line,
HTAPI_CALL ht_Call,
PDRVLINE *ppLine,
PDRVCALL *ppCall
)
{
LONG lRes;
PDRVCALL pCall;
PDRVLINE pLine;
lRes = GetLineObjWithReadLock((HDRVLINE)ht_Line, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
*ppLine = pLine;
//
// figure out whether this is an inbound call or
// outbound call: for inbound calls, ht_Call is
// generated by NDISTAPI and bit 0 is 1;
// for outbound calls, ht_Call is a TSP handle
// and we make sure that bit 0 is 0
//
if (ht_Call & 0x1)
{
// inbound call: we need to walk the list
// of inbound calls on this line and
// find the right one
if ((pCall = pLine->pInboundCalls) != NULL)
{
while (pCall && (pCall->ht_Call != ht_Call))
{
pCall = pCall->pNext;
}
}
if (NULL == pCall || pCall->dwKey != INBOUND_CALL_KEY)
{
TspLog(DL_WARNING,
"GetLineAndCallObjWithReadLock: "\
"inbound ht_call(%p) closed already",
ht_Call);
ReleaseObjReadLock((HANDLE)ht_Line);
return LINEERR_INVALCALLHANDLE;
}
// call the following to increase the ref count
lRes = AcquireObjReadLock((HANDLE)pCall->hdCall);
if (lRes != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)ht_Line);
return lRes;
}
*ppCall = pCall;
return TAPI_SUCCESS;
}
// ht_Call is a TSP handle and the call is OUTBOUND
lRes = GetObjWithReadLock((HANDLE)ht_Call, &pCall);
if (lRes != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)ht_Line);
return lRes;
}
ASSERT(pCall != NULL);
if (pCall->dwKey != OUTBOUND_CALL_KEY)
{
TspLog(DL_WARNING,
"GetLineAndCallObjWithReadLock: bad call handle(%p, %x)",
ht_Call, pCall->dwKey);
ReleaseObjReadLock((HANDLE)ht_Call);
ReleaseObjReadLock((HANDLE)ht_Line);
return LINEERR_INVALCALLHANDLE;
}
*ppCall = pCall;
return TAPI_SUCCESS;
}
//
// allocates mem for a NDISTAPI_REQUEST plus some initialization
//
LONG
WINAPI
PrepareSyncRequest(
ULONG Oid,
ULONG ulDeviceID,
DWORD dwDataSize,
PNDISTAPI_REQUEST *ppNdisTapiRequest
)
{
PNDISTAPI_REQUEST pNdisTapiRequest =
(PNDISTAPI_REQUEST)AllocRequest(dwDataSize + sizeof(NDISTAPI_REQUEST));
if (NULL == pNdisTapiRequest)
{
TspLog(DL_ERROR,
"PrepareSyncRequest: failed to alloc sync req for oid(%x)",
Oid);
return LINEERR_NOMEM;
}
pNdisTapiRequest->Oid = Oid;
pNdisTapiRequest->ulDeviceID = ulDeviceID;
pNdisTapiRequest->ulDataSize = dwDataSize;
EnterCriticalSection(&gRequestIDCritSec);
// setting ulRequestId of NDIS_TAPI_xxxx
if ((*((ULONG *)pNdisTapiRequest->Data) = ++gdwRequestID) >= 0x7fffffff)
{
gdwRequestID = 1;
}
LeaveCriticalSection(&gRequestIDCritSec);
*ppNdisTapiRequest = pNdisTapiRequest;
return TAPI_SUCCESS;
}
//
// allocates mem for a ASYNC_REQUEST_WRAPPER plus some initialization
//
LONG
WINAPI
PrepareAsyncRequest(
ULONG Oid,
ULONG ulDeviceID,
DWORD dwRequestID,
DWORD dwDataSize,
PASYNC_REQUEST_WRAPPER *ppAsyncReqWrapper
)
{
PNDISTAPI_REQUEST pNdisTapiRequest;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
// alloc & init an async request wrapper
pAsyncReqWrapper = (PASYNC_REQUEST_WRAPPER)
AllocRequest(dwDataSize + sizeof(ASYNC_REQUEST_WRAPPER));
if (NULL == pAsyncReqWrapper)
{
TspLog(DL_ERROR,
"PrepareAsyncRequest: failed to alloc async req for oid(%x)",
Oid);
return LINEERR_NOMEM;
}
// don't need to create an event when using completion ports
pAsyncReqWrapper->Overlapped.hEvent = (HANDLE)NULL;
pAsyncReqWrapper->dwKey = ASYNCREQWRAPPER_KEY;
pAsyncReqWrapper->dwRequestID = dwRequestID;
pAsyncReqWrapper->pfnPostProcess = (POSTPROCESSPROC)NULL;
// initialize the critical section, ref the request wrapper.
// NOTE: this crit sec will be deleted by the last deref.
InitializeCriticalSection(&pAsyncReqWrapper->CritSec);
pAsyncReqWrapper->RefCount = 1;
// safely initialize the driver request
pNdisTapiRequest = &(pAsyncReqWrapper->NdisTapiRequest);
pNdisTapiRequest->Oid = Oid;
pNdisTapiRequest->ulDeviceID = ulDeviceID;
pNdisTapiRequest->ulDataSize = dwDataSize;
EnterCriticalSection(&gRequestIDCritSec);
if ((*((ULONG *)pNdisTapiRequest->Data) = ++gdwRequestID) >= 0x7fffffff)
{
gdwRequestID = 1;
}
LeaveCriticalSection(&gRequestIDCritSec);
*ppAsyncReqWrapper = pAsyncReqWrapper;
return TAPI_SUCCESS;
}
//
// makes a non-overlapped request to ndistapi.sys
// so it doesn't return until the req is completed
//
LONG
WINAPI
SyncDriverRequest(
DWORD dwIoControlCode,
PNDISTAPI_REQUEST pNdisTapiRequest
)
{
BOOL bRes;
DWORD cbReturned;
TspLog(DL_INFO,
"SyncDriverRequest: oid(%s), devID(%x), reqID(%x), hdCall(%x)",
pszOidNames[pNdisTapiRequest->Oid - OID_TAPI_ACCEPT],
pNdisTapiRequest->ulDeviceID,
*((ULONG *)pNdisTapiRequest->Data),
*(((ULONG *)pNdisTapiRequest->Data) + 1));
// mark the request as being processed by the driver
MarkRequest(pNdisTapiRequest);
bRes = DeviceIoControl(ghDriverSync,
dwIoControlCode,
pNdisTapiRequest,
(DWORD)(sizeof(NDISTAPI_REQUEST) +
pNdisTapiRequest->ulDataSize),
pNdisTapiRequest,
(DWORD)(sizeof(NDISTAPI_REQUEST) +
pNdisTapiRequest->ulDataSize),
&cbReturned,
0);
// unmark the request now that the ioctl is completed
UnmarkRequest(pNdisTapiRequest);
if (bRes != TRUE)
{
TspLog(DL_ERROR, "SyncDriverRequest: IoCtl(Oid %x) failed(%d)",
pNdisTapiRequest->Oid, GetLastError());
return (LINEERR_OPERATIONFAILED);
}
else
{
// the errors returned by ndistapi.sys don't match the TAPI
// LINEERR_'s, so return the translated values (but preserve
// the original driver return val so it's possible to distinguish
// between NDISTAPIERR_DEVICEOFFLINE & LINEERR_OPERATIONUNAVAIL,
// etc.)
return (TranslateDriverResult(pNdisTapiRequest->ulReturnValue));
}
}
//
// make an overlapped call
//
LONG
WINAPI
AsyncDriverRequest(
DWORD dwIoControlCode,
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper
)
{
BOOL bRes;
LONG lRes;
DWORD dwRequestSize, cbReturned, dwLastError;
TspLog(DL_INFO,
"AsyncDriverRequest: oid(%s), devID(%x), ReqID(%x), "
"reqID(%x), hdCall(%x)",
pszOidNames[pAsyncReqWrapper->NdisTapiRequest.Oid -
OID_TAPI_ACCEPT],
pAsyncReqWrapper->NdisTapiRequest.ulDeviceID,
pAsyncReqWrapper->dwRequestID,
*((ULONG *)pAsyncReqWrapper->NdisTapiRequest.Data),
*(((ULONG *)pAsyncReqWrapper->NdisTapiRequest.Data) + 1));
lRes = (LONG)pAsyncReqWrapper->dwRequestID;
dwRequestSize = sizeof(NDISTAPI_REQUEST) +
(pAsyncReqWrapper->NdisTapiRequest.ulDataSize - 1);
REF_ASYNC_REQUEST_WRAPPER(pAsyncReqWrapper);
// mark the request as being processed by the driver
MarkRequest(pAsyncReqWrapper);
bRes = DeviceIoControl(
ghDriverAsync,
dwIoControlCode,
&pAsyncReqWrapper->NdisTapiRequest,
dwRequestSize,
&pAsyncReqWrapper->NdisTapiRequest,
dwRequestSize,
&cbReturned,
&pAsyncReqWrapper->Overlapped
);
DEREF_ASYNC_REQUEST_WRAPPER(pAsyncReqWrapper);
if (bRes != TRUE) {
dwLastError = GetLastError();
if (dwLastError != ERROR_IO_PENDING) {
TspLog(DL_ERROR, "AsyncDriverRequest: IoCtl(oid %x) failed(%d)",
pAsyncReqWrapper->NdisTapiRequest.Oid, dwLastError);
// the ioctl failed and was not pended
// this does not trigger the completion port
// so we have to cleanup here.
(*gpfnCompletionProc)(pAsyncReqWrapper->dwRequestID,
LINEERR_OPERATIONFAILED);
DEREF_ASYNC_REQUEST_WRAPPER(pAsyncReqWrapper);
}
}
return lRes;
}
//
// reports to TAPI events that occur on the line or on calls on the line
//
VOID
WINAPI
ProcessEvent(
PNDIS_TAPI_EVENT pEvent
)
{
LONG lRes;
ULONG ulMsg = pEvent->ulMsg;
HTAPI_LINE ht_Line = (HTAPI_LINE)pEvent->htLine;
HTAPI_CALL ht_Call = (HTAPI_CALL)pEvent->htCall;
TspLog(DL_INFO,
"ProcessEvent: event(%p), msg(%x), ht_line(%p), ht_call(%p), "\
"p1(%p), p2(%p), p3(%p)",
pEvent, ulMsg, ht_Line, ht_Call,
pEvent->ulParam1, pEvent->ulParam2, pEvent->ulParam3);
switch (ulMsg)
{
case LINE_ADDRESSSTATE:
case LINE_CLOSE:
case LINE_DEVSPECIFIC:
case LINE_LINEDEVSTATE:
{
PDRVLINE pLine;
lRes = GetLineObjWithReadLock((HDRVLINE)ht_Line, &pLine);
if (lRes != TAPI_SUCCESS)
{
break;
}
TspLog(DL_INFO,
"PE::fnLineEvent: msg(%x), line(%p), p1(%p), p2(%p), p3(%p)",
ulMsg, pLine->htLine,
pEvent->ulParam1, pEvent->ulParam2, pEvent->ulParam3);
(*gpfnLineEvent)(pLine->htLine,
(HTAPICALL)NULL,
ulMsg,
(DWORD_PTR)pEvent->ulParam1,
(DWORD_PTR)pEvent->ulParam2,
(DWORD_PTR)pEvent->ulParam3);
ReleaseObjReadLock((HANDLE)ht_Line);
break;
}
case LINE_CALLDEVSPECIFIC:
case LINE_CALLINFO:
{
PDRVLINE pLine;
PDRVCALL pCall;
HDRVLINE hdLine;
lRes = GetLineAndCallObjWithReadLock(ht_Line, ht_Call, &pLine, &pCall);
if (lRes != TAPI_SUCCESS)
{
break;
}
hdLine = pCall->hdLine;
TspLog(DL_INFO,
"PE::fnLineEvent: msg(%x), htline(%p), htcall(%p), "\
"p1(%p), p2(%p), p3(%p)",
ulMsg, pLine->htLine, pCall->htCall,
pEvent->ulParam1, pEvent->ulParam2, pEvent->ulParam3);
(*gpfnLineEvent)(pLine->htLine,
pCall->htCall,
ulMsg,
(DWORD_PTR)pEvent->ulParam1,
(DWORD_PTR)pEvent->ulParam2,
(DWORD_PTR)pEvent->ulParam3);
ReleaseObjReadLock((HANDLE)pCall->hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
break;
}
case LINE_CALLSTATE:
{
PDRVLINE pLine;
PDRVCALL pCall;
HDRVLINE hdLine;
lRes = GetLineAndCallObjWithReadLock(ht_Line, ht_Call, &pLine, &pCall);
// we may still receive a few events
// for calls that have been closed/dropped
if (lRes != TAPI_SUCCESS)
{
break;
}
hdLine = pCall->hdLine;
//
// for outbound calls there exists a race condition between
// receiving the first call state msg(s) and receiving the
// make call completion notification (if we pass a call state
// msg on to tapi for a call that hasn't been completed yet
// tapi will just discard the msg since the htCall really
// isn't valid at that point). So if htCall references a
// valid outbound call which hasn't completed yet, we'll save
// the call state params, and pass them on to tapi after we
// get & indicate a (successful) completion notification.
//
if ((OUTBOUND_CALL_KEY == pCall->dwKey) &&
(TRUE == pCall->bIncomplete))
{
TspLog(DL_INFO,
"ProcessEvent: incomplete outbound call, saving state");
pCall->dwPendingCallState = (DWORD)pEvent->ulParam1;
pCall->dwPendingCallStateMode = (DWORD)pEvent->ulParam2;
pCall->dwPendingMediaMode = (DWORD)pEvent->ulParam3;
ReleaseObjReadLock((HANDLE)pCall->hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
break;
}
if (pCall->bIdle)
{
ReleaseObjReadLock((HANDLE)pCall->hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
break;
}
else if (LINECALLSTATE_DISCONNECTED == pEvent->ulParam1 ||
LINECALLSTATE_IDLE == pEvent->ulParam1)
{
HDRVCALL hdCall = pCall->hdCall;
// we need to acquire a write lock to update bIdle,
// make sure releasing the read lock before doing so.
ReleaseObjReadLock((HANDLE)hdCall);
lRes = AcquireObjWriteLock((HANDLE)hdCall);
if (lRes != TAPI_SUCCESS)
{
TspLog(DL_WARNING,
"ProcessEvent: failed to acquire write lock for call(%p)",
hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
break;
}
pCall->bIdle = TRUE;
ReleaseObjWriteLock((HANDLE)hdCall);
// reacquire the read lock
lRes = AcquireObjReadLock((HANDLE)hdCall);
if (lRes != TAPI_SUCCESS)
{
TspLog(DL_WARNING,
"ProcessEvent: failed to reacquire read lock for call(%p)",
hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
break;
}
}
TspLog(DL_INFO,
"PE::fnLineEvent(CALLSTATE): htline(%p), htcall(%p), "\
"p1(%p), p2(%p), p3(%p)",
pLine->htLine, pCall->htCall,
pEvent->ulParam1, pEvent->ulParam2, pEvent->ulParam3);
(*gpfnLineEvent)(pLine->htLine,
pCall->htCall,
ulMsg,
(DWORD_PTR)pEvent->ulParam1,
(DWORD_PTR)pEvent->ulParam2,
(DWORD_PTR)pEvent->ulParam3);
//
// For old style miniports we want to indicate an IDLE
// immediately following the disconnected (several of
// the initial NDIS WAN miniports did not indicate an
// IDLE call state due to doc confusion)
//
if (LINECALLSTATE_DISCONNECTED == pEvent->ulParam1)
{
TspLog(DL_INFO,
"PE::fnLineEvent(CALLSTATE_IDLE): htline(%p), htcall(%p), p3(%p)",
pLine->htLine, pCall->htCall, pEvent->ulParam3);
(*gpfnLineEvent)(pLine->htLine,
pCall->htCall,
ulMsg,
(DWORD_PTR)LINECALLSTATE_IDLE,
(DWORD_PTR)0,
(DWORD_PTR)pEvent->ulParam3);
}
ReleaseObjReadLock((HANDLE)pCall->hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
break;
}
case LINE_NEWCALL:
{
HDRVCALL hdCall;
PDRVCALL pCall;
PDRVLINE pLine;
lRes = GetLineObjWithWriteLock((HDRVLINE)ht_Line, &pLine);
if (lRes != TAPI_SUCCESS)
{
break;
}
// alloc & initialize a new DRVCALL object
if (pCall = AllocCallObj(sizeof(DRVCALL)))
{
pCall->dwKey = INBOUND_CALL_KEY;
pCall->hd_Call = (HDRV_CALL)pEvent->ulParam1;
pCall->ht_Call = (HTAPI_CALL)pEvent->ulParam2;
pCall->hdLine = (HDRVLINE)ht_Line;
pCall->bIncomplete = FALSE;
}
//
// if the new call object allocation failed above then we
// want to tell the driver to drop & close the call,
// then just break
//
if (NULL == pCall)
{
PNDISTAPI_REQUEST pNdisTapiRequestDrop;
PNDISTAPI_REQUEST pNdisTapiRequestCloseCall;
PNDIS_TAPI_DROP pNdisTapiDrop;
PNDIS_TAPI_CLOSE_CALL pNdisTapiCloseCall;
if ((lRes = PrepareSyncRequest(
OID_TAPI_DROP, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_DROP), // size of drve req data
&pNdisTapiRequestDrop // ptr to ptr to request buf
)) != TAPI_SUCCESS)
{
ReleaseObjWriteLock((HANDLE)ht_Line);
break;
}
pNdisTapiDrop = (PNDIS_TAPI_DROP)pNdisTapiRequestDrop->Data;
pNdisTapiDrop->hdCall = (HDRV_CALL) pEvent->ulParam1;
pNdisTapiDrop->ulUserUserInfoSize = 0;
SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequestDrop);
FreeRequest(pNdisTapiRequestDrop);
if ((lRes = PrepareSyncRequest(
OID_TAPI_CLOSE_CALL, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_CLOSE_CALL), // size of drve req data
&pNdisTapiRequestCloseCall // ptr to ptr to request buf
)) != TAPI_SUCCESS)
{
ReleaseObjWriteLock((HANDLE)ht_Line);
break;
}
pNdisTapiCloseCall =
(PNDIS_TAPI_CLOSE_CALL)pNdisTapiRequestCloseCall->Data;
pNdisTapiCloseCall->hdCall = (HDRV_CALL) pEvent->ulParam1;
SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO,
pNdisTapiRequestCloseCall);
FreeRequest(pNdisTapiRequestCloseCall);
ReleaseObjWriteLock((HANDLE)ht_Line);
break;
}
ASSERT(pCall != NULL);
pCall->dwDeviceID = pLine->dwDeviceID;
// make sure releasing write lock before calling OpenObjHandle()
// to avoid deadlock on acquiring write lock for the global mapper
ReleaseObjWriteLock((HANDLE)ht_Line);
lRes = OpenObjHandle(pCall, FreeCallObj, (HANDLE *)&hdCall);
if (lRes != TAPI_SUCCESS)
{
TspLog(DL_ERROR,
"ProcessEvent: failed to map obj(%p) to handle",
pCall);
FreeCallObj(pCall);
break;
}
// reacquire the write lock
lRes = AcquireObjWriteLock((HANDLE)ht_Line);
if (lRes != TAPI_SUCCESS)
{
TspLog(DL_ERROR,
"ProcessEvent: failed to reacquire write lock for obj(%p)",
ht_Line);
CloseObjHandle((HANDLE)hdCall);
break;
}
// save the TSP handle
pCall->hdCall = hdCall;
// send the LINE_NEWCALL to TAPI, getting back the TAPI call handle
TspLog(DL_INFO,
"PE::fnLineEvent(NEWCALL): htline(%p), call(%p)",
pLine->htLine, hdCall);
(*gpfnLineEvent)(pLine->htLine,
(HTAPICALL) NULL,
LINE_NEWCALL,
(DWORD_PTR)hdCall,
(DWORD_PTR)&pCall->htCall,
0);
//
// insert the new call into the line's inbound calls list
// regardless of the result of the LINE_NEWCALL
// if it failed, we'll destroy the call next, and
// TSPI_lineCloseCall will expect the call to be
// in the line's inbound call list
//
if ((pCall->pNext = pLine->pInboundCalls) != NULL)
{
pCall->pNext->pPrev = pCall;
}
pLine->pInboundCalls = pCall;
ReleaseObjWriteLock((HANDLE)ht_Line);
//
// if TAPI didn't create it's own representation of this
// cal (if pCall->htCall == NULL), then either:
//
// 1) the line is in the process of being closed, or
// 2) TAPI was unable to allocate the necessary resources
//
// ...so we'll close the call
//
if (NULL == pCall->htCall)
{
TspLog(DL_WARNING, "ProcessEvent: TAPI failed to create "
"its own handle for the new call, so we close the call");
TSPI_lineCloseCall(hdCall);
}
break;
}
case LINE_CREATE:
TspLog(DL_INFO,
"PE::fnLineEvent(CREATE): ghProvider(%p), p2(%p), p3(%p)",
ghProvider, pEvent->ulParam2, pEvent->ulParam3);
(*gpfnLineEvent)((HTAPILINE) NULL,
(HTAPICALL) NULL,
ulMsg,
(DWORD_PTR)ghProvider,
(DWORD_PTR)pEvent->ulParam2,
(DWORD_PTR)pEvent->ulParam3);
break;
default:
TspLog(DL_ERROR, "ProcessEvent: unknown msg(%x)", ulMsg);
break;
} // switch
}
//
// thread proc that retrieves and processes completed requests
// and async events
//
VOID
AsyncEventsThread(
LPVOID lpParams
)
{
OVERLAPPED overlapped;
DWORD cbReturned;
//
// send an IOCTL to retrieve async events
//
overlapped.hEvent = NULL; // don't need event when using completion ports
gpAsyncEventsThreadInfo->pBuf->ulTotalSize =
gpAsyncEventsThreadInfo->dwBufSize - sizeof(NDISTAPI_EVENT_DATA) + 1;
gpAsyncEventsThreadInfo->pBuf->ulUsedSize = 0;
if (DeviceIoControl(
ghDriverAsync,
IOCTL_NDISTAPI_GET_LINE_EVENTS,
gpAsyncEventsThreadInfo->pBuf,
sizeof(NDISTAPI_EVENT_DATA),
gpAsyncEventsThreadInfo->pBuf,
gpAsyncEventsThreadInfo->dwBufSize,
&cbReturned,
&overlapped
) != TRUE)
{
DWORD dwLastError = GetLastError();
if (dwLastError != ERROR_IO_PENDING)
{
TspLog(DL_ERROR,
"AsyncEventsThread: IoCtl(GetEvent) failed(%d)",
dwLastError);
}
ASSERT(ERROR_IO_PENDING == dwLastError);
}
// loop waiting for completed requests and retrieving async events
while (1)
{
BOOL bRes;
LPOVERLAPPED lpOverlapped;
PNDIS_TAPI_EVENT pEvent;
// wait for a request to complete
while (1) {
DWORD dwNumBytesTransferred;
DWORD_PTR dwCompletionKey;
bRes = GetQueuedCompletionStatus(
ghCompletionPort,
&dwNumBytesTransferred,
&dwCompletionKey,
&lpOverlapped,
(DWORD)-1); // infinite wait
if (bRes) {
//
// GetQueuedCompletion returned success so if our
// overlapped field is non-NULL then process the
// event. If the overlapped field is NULL try
// to get another event.
//
if (lpOverlapped != NULL) {
break;
}
TspLog(DL_WARNING,
"AsyncEventsThread: GetQueuedCompletionStatus "\
"lpOverlapped == NULL!");
} else {
//
// Error returned from GetQueuedCompletionStatus so
// shutdown the thread.
//
TspLog(DL_ERROR,
"AsyncEventsThread: GetQueuedCompletionStatus "\
"failed(%d)", GetLastError());
TspLog(DL_WARNING, "AsyncEventsThread: exiting thread");
ExitThread (0);
}
}
//
// check the returned overlapped struct to determine if
// we have some events to process or a completed request
//
if (lpOverlapped == &overlapped)
{
DWORD i;
TspLog(DL_INFO, "AsyncEventsThread: got a line event");
// handle the events
pEvent = (PNDIS_TAPI_EVENT)gpAsyncEventsThreadInfo->pBuf->Data;
for (i = 0;
i < (gpAsyncEventsThreadInfo->pBuf->ulUsedSize /
sizeof(NDIS_TAPI_EVENT));
i++
)
{
ProcessEvent(pEvent);
pEvent++;
}
//
// send another IOCTL to retrieve new async events
//
overlapped.hEvent = NULL;
gpAsyncEventsThreadInfo->pBuf->ulTotalSize =
gpAsyncEventsThreadInfo->dwBufSize -
sizeof(NDISTAPI_EVENT_DATA) + 1;
gpAsyncEventsThreadInfo->pBuf->ulUsedSize = 0;
if (DeviceIoControl(
ghDriverAsync,
IOCTL_NDISTAPI_GET_LINE_EVENTS,
gpAsyncEventsThreadInfo->pBuf,
sizeof(NDISTAPI_EVENT_DATA),
gpAsyncEventsThreadInfo->pBuf,
gpAsyncEventsThreadInfo->dwBufSize,
&cbReturned,
&overlapped
) != TRUE)
{
DWORD dwLastError = GetLastError();
if (dwLastError != ERROR_IO_PENDING) {
TspLog(DL_ERROR,
"AsyncEventsThread: IoCtl(GetEvent) failed(%d)",
dwLastError);
TspLog(DL_INFO, "AsyncEventsThread: exiting thread");
ExitThread (0);
}
}
}
else
{
LONG lRes;
DWORD dwRequestID, callStateMsgParams[5];
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper =
(PASYNC_REQUEST_WRAPPER)lpOverlapped;
TspLog(DL_INFO, "AsyncEventsThread: got a completed req");
// verify that pointer is valid
if (pAsyncReqWrapper->dwKey != ASYNCREQWRAPPER_KEY) {
TspLog(DL_WARNING, "AsyncEventsThread: got a bogus req");
continue;
}
dwRequestID = pAsyncReqWrapper->dwRequestID;
// unmark the request now that the ioctl is completed
UnmarkRequest(pAsyncReqWrapper);
lRes = TranslateDriverResult(
pAsyncReqWrapper->NdisTapiRequest.ulReturnValue
);
TspLog(DL_INFO,
"AsyncEventsThread: req(%p) with reqID(%x) returned lRes(%x)",
pAsyncReqWrapper, dwRequestID, lRes);
// call the post processing proc if appropriate
callStateMsgParams[0] = 0;
if (pAsyncReqWrapper->pfnPostProcess)
{
(*pAsyncReqWrapper->pfnPostProcess)(
pAsyncReqWrapper,
lRes,
callStateMsgParams
);
}
// free the async request wrapper
DEREF_ASYNC_REQUEST_WRAPPER(pAsyncReqWrapper);
// call completion proc
TspLog(DL_TRACE,
"AsyncEventsThread: call compproc with ReqID(%x), lRes(%x)",
dwRequestID, lRes);
(*gpfnCompletionProc)(dwRequestID, lRes);
// when outbounding call completes, we need to
// report back the saved call state
if (callStateMsgParams[0])
{
TspLog(DL_INFO,
"AsyncEventsThread: report back the saved call state");
TspLog(DL_INFO,
"AET::fnLineEvent(CALLSTATE): htline(%p), htcall(%p), "\
"p1(%p), p2(%p), p3(%p)",
callStateMsgParams[0], callStateMsgParams[1],
callStateMsgParams[2], callStateMsgParams[3],
callStateMsgParams[4]);
(*gpfnLineEvent)((HTAPILINE)ULongToPtr(callStateMsgParams[0]),
(HTAPICALL)ULongToPtr(callStateMsgParams[1]),
LINE_CALLSTATE,
(DWORD_PTR)callStateMsgParams[2],
(DWORD_PTR)callStateMsgParams[3],
(DWORD_PTR)callStateMsgParams[4]);
}
}
} // while
}
HDRV_CALL
GetNdisTapiHandle(
PDRVCALL pCall,
LONG *plRes
)
{
HDRVCALL hdCall;
PDRVCALL pCallLocal = pCall;
LONG lRes;
ASSERT(pCallLocal != NULL);
hdCall = pCall->hdCall;
if(plRes != NULL)
{
*plRes = TAPI_SUCCESS;
}
//
// if the call is outbound, wait until the make call request
// has completed so we don't send a bad NDISTAPI handle down
// to the driver
//
if (OUTBOUND_CALL_KEY == pCallLocal->dwKey)
{
ASSERT(plRes != NULL);
if (pCallLocal->bIncomplete)
{
TspLog(DL_INFO,
"GetNdisTapiHandle: wait for the outbound call to complete...");
do
{
ASSERT(plRes != NULL);
//
// Release the lock before going to sleep.
// otherwise we get into a deadlock.
//
ReleaseObjReadLock((HANDLE) hdCall);
Sleep(250);
//
// ReAcquire Lock. break if we can't
//
lRes = GetCallObjWithReadLock(hdCall, &pCallLocal);
if(lRes != TAPI_SUCCESS)
{
*plRes = lRes;
break;
}
} while (pCallLocal->bIncomplete);
}
}
return pCall->hd_Call;
}
DWORD
GetDestAddressLength(
LPCWSTR lpszDestAddress,
DWORD dwOrgDALength,
UINT *pCodePage
)
{
DWORD dwLength;
ASSERT(lpszDestAddress != NULL);
ASSERT(pCodePage != NULL);
if (*pCodePage == CP_ACP)
{
// If code page is CP_ACP, return the original length to
// keep the old behavior.
dwLength = dwOrgDALength;
}
else
{
dwLength = WideCharToMultiByte(
*pCodePage,
0,
lpszDestAddress,
dwOrgDALength,
NULL,
0,
NULL,
NULL
);
if (dwLength == 0)
{
// WideCharToMultiByte() failed, use CP_ACP to show
// the old behavior.
*pCodePage = CP_ACP;
dwLength = dwOrgDALength;
}
}
return dwLength;
}
//
// TSPI_lineXXX functions
//
LONG
TSPIAPI
TSPI_lineAccept(
DRV_REQUESTID dwRequestID,
HDRVCALL hdCall,
LPCSTR lpsUserUserInfo,
DWORD dwSize
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_ACCEPT pNdisTapiAccept;
TspLog(DL_TRACE, "lineAccept(%d): reqID(%x), call(%p)",
++dwSum, dwRequestID, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareAsyncRequest(
OID_TAPI_ACCEPT, // opcode
pCall->dwDeviceID, // device id
dwRequestID, // request id
sizeof(NDIS_TAPI_ACCEPT) + dwSize, // size of drv request data
&pAsyncReqWrapper // ptr to ptr to request buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiAccept =
(PNDIS_TAPI_ACCEPT)pAsyncReqWrapper->NdisTapiRequest.Data;
pNdisTapiAccept->hdCall = GetNdisTapiHandle(pCall, NULL);
if ((pNdisTapiAccept->ulUserUserInfoSize = dwSize) != 0)
{
CopyMemory(pNdisTapiAccept->UserUserInfo, lpsUserUserInfo, dwSize);
}
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pAsyncReqWrapper);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineAnswer(
DRV_REQUESTID dwRequestID,
HDRVCALL hdCall,
LPCSTR lpsUserUserInfo,
DWORD dwSize
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_ANSWER pNdisTapiAnswer;
TspLog(DL_TRACE, "lineAnswer(%d): reqID(%x), call(%p)",
++dwSum, dwRequestID, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareAsyncRequest(
OID_TAPI_ANSWER, // opcode
pCall->dwDeviceID, // device id
dwRequestID, // request id
sizeof(NDIS_TAPI_ANSWER) + dwSize, // size of drv request data
&pAsyncReqWrapper // ptr to ptr to request buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiAnswer =
(PNDIS_TAPI_ANSWER)pAsyncReqWrapper->NdisTapiRequest.Data;
pNdisTapiAnswer->hdCall = GetNdisTapiHandle(pCall, NULL);
if ((pNdisTapiAnswer->ulUserUserInfoSize = dwSize) != 0)
{
CopyMemory(pNdisTapiAnswer->UserUserInfo, lpsUserUserInfo, dwSize);
}
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pAsyncReqWrapper);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineClose(
HDRVLINE hdLine
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_CLOSE pNdisTapiClose;
TspLog(DL_TRACE, "lineClose(%d): line(%p)", ++dwSum, hdLine);
lRes = GetLineObjWithWriteLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_CLOSE, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_CLOSE), // size of drve req data
&pNdisTapiRequest // ptr to ptr to request buffer
)) != TAPI_SUCCESS)
{
ReleaseObjWriteLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiClose = (PNDIS_TAPI_CLOSE)pNdisTapiRequest->Data;
// mark line as invalid so any related events that show up
// will be discarded.
pLine->dwKey = INVALID_KEY;
pNdisTapiClose->hdLine = pLine->hd_Line;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequest);
FreeRequest(pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
lRes = DecommitNegotiatedTSPIVersion(pLine->dwDeviceID);
}
ReleaseObjWriteLock((HANDLE)hdLine);
// release line resources
CloseObjHandle((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineCloseCall(
HDRVCALL hdCall
)
{
static DWORD dwSum = 0;
LONG lRes;
HDRVLINE hdLine;
PDRVLINE pLine;
PDRVCALL pCall;
PNDISTAPI_REQUEST pNdisTapiRequestCloseCall;
PNDIS_TAPI_CLOSE_CALL pNdisTapiCloseCall;
BOOL bInboundCall;
HDRV_CALL NdisTapiHandle;
TspLog(DL_TRACE, "lineCloseCall(%d): call(%p)", ++dwSum, hdCall);
lRes = GetLineHandleFromCallHandle(hdCall, &hdLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
//
// Initially we can't acquire the write lock directly
// because we might spin-wait in GetNdisTapiHandle so
// we grab the readlock instead.
//
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
bInboundCall = (INBOUND_CALL_KEY == pCall->dwKey);
NdisTapiHandle = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE) hdLine);
return lRes;
}
ReleaseObjReadLock((HANDLE)hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
//
// Now acquire the write lock
//
lRes = AcquireObjWriteLock((HANDLE)hdLine);
if (lRes != TAPI_SUCCESS) {
return lRes;
}
lRes = AcquireObjWriteLock((HANDLE)hdCall);
if (lRes != TAPI_SUCCESS) {
ReleaseObjWriteLock((HANDLE)hdLine);
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_CLOSE_CALL, // opcode
pCall->dwDeviceID, // device id
sizeof(NDIS_TAPI_CLOSE_CALL), // size of drve req data
&pNdisTapiRequestCloseCall // ptr to ptr to request buffer
)) != TAPI_SUCCESS)
{
ReleaseObjWriteLock((HANDLE)hdCall);
ReleaseObjWriteLock((HANDLE)hdLine);
return lRes;
}
// @@@ for legacy NDISWAN ISDN miniports:
// since there's no more "automatic" call dropping in
// TAPI when an app has closed the line & there are
// existing non-IDLE calls, legacy NDIS WAN ISDN miniports
// rely on seeing an OID_TAPI_DROP, we need to synthesize
// this behavior if the call has not previously be dropped.
if (!pCall->bDropped)
{
PNDISTAPI_REQUEST pNdisTapiRequestDrop;
PNDIS_TAPI_DROP pNdisTapiDrop;
TspLog(DL_INFO, "lineCloseCall: synthesize DROP req");
if ((lRes = PrepareSyncRequest(
OID_TAPI_DROP, // opcode
pCall->dwDeviceID, // device id
sizeof(NDIS_TAPI_DROP), // size of drve req data
&pNdisTapiRequestDrop // ptr to ptr to request buffer
)) != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequestCloseCall);
ReleaseObjWriteLock((HANDLE)hdCall);
ReleaseObjWriteLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiDrop = (PNDIS_TAPI_DROP)pNdisTapiRequestDrop->Data;
pNdisTapiDrop->hdCall = NdisTapiHandle;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequestDrop);
// done with the drop sync req
FreeRequest(pNdisTapiRequestDrop);
if (lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequestCloseCall);
ReleaseObjWriteLock((HANDLE)hdCall);
ReleaseObjWriteLock((HANDLE)hdLine);
return lRes;
}
}
// mark the call as bad so any events get discarded
pCall->dwKey = INVALID_KEY;
// set up the params & call the driver
pNdisTapiCloseCall = (PNDIS_TAPI_CLOSE_CALL)pNdisTapiRequestCloseCall->Data;
pNdisTapiCloseCall->hdCall = NdisTapiHandle;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO,
pNdisTapiRequestCloseCall);
FreeRequest(pNdisTapiRequestCloseCall);
// if inbound call, remove it from the list
if (bInboundCall)
{
if (pCall->pNext)
{
pCall->pNext->pPrev = pCall->pPrev;
}
if (pCall->pPrev)
{
pCall->pPrev->pNext = pCall->pNext;
}
else
{
pLine->pInboundCalls = pCall->pNext;
}
}
ReleaseObjWriteLock((HANDLE)hdCall);
ReleaseObjWriteLock((HANDLE)hdLine);
// free the call struct now that the call is closed
CloseObjHandle((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineConditionalMediaDetection(
HDRVLINE hdLine,
DWORD dwMediaModes,
LPLINECALLPARAMS const lpCallParams
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION pNdisTapiConditionalMediaDetection;
TspLog(DL_TRACE, "lineConditionalMediaDetection(%d): line(%p), mode(%x)",
++dwSum, hdLine, dwMediaModes);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_CONDITIONAL_MEDIA_DETECTION, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_CONDITIONAL_MEDIA_DETECTION) +
(lpCallParams->dwTotalSize - sizeof(LINE_CALL_PARAMS)),
&pNdisTapiRequest // ptr to ptr to
// req buffer
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiConditionalMediaDetection =
(PNDIS_TAPI_CONDITIONAL_MEDIA_DETECTION) pNdisTapiRequest->Data;
pNdisTapiConditionalMediaDetection->hdLine = pLine->hd_Line;
pNdisTapiConditionalMediaDetection->ulMediaModes = dwMediaModes;
CopyMemory(
&pNdisTapiConditionalMediaDetection->LineCallParams,
lpCallParams,
lpCallParams->dwTotalSize
);
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequest);
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
PASCAL
TSPI_lineDevSpecific_postProcess(
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper,
LONG lRes,
PDWORD_PTR callStateMsgParams
)
{
TspLog(DL_TRACE, "lineDevSpecific_post: lRes(%x)", lRes);
if (TAPI_SUCCESS == lRes)
{
PNDIS_TAPI_DEV_SPECIFIC pNdisTapiDevSpecific =
(PNDIS_TAPI_DEV_SPECIFIC)pAsyncReqWrapper->NdisTapiRequest.Data;
CopyMemory(
(LPVOID) pAsyncReqWrapper->dwRequestSpecific,
pNdisTapiDevSpecific->Params,
pNdisTapiDevSpecific->ulParamsSize
);
}
return lRes;
}
LONG
TSPIAPI
TSPI_lineDevSpecific(
DRV_REQUESTID dwRequestID,
HDRVLINE hdLine,
DWORD dwAddressID,
HDRVCALL hdCall,
LPVOID lpParams,
DWORD dwSize
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PDRVCALL pCall = NULL;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_DEV_SPECIFIC pNdisTapiDevSpecific;
TspLog(DL_TRACE,
"lineDevSpecific(%d): reqID(%x), line(%p), addressID(%x), call(%p)",
++dwSum, dwRequestID, hdLine, dwAddressID, hdCall);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareAsyncRequest(
OID_TAPI_DEV_SPECIFIC, // opcode
pLine->dwDeviceID, // device id
dwRequestID, // request id
sizeof(NDIS_TAPI_DEV_SPECIFIC) + // size of drv request data
(dwSize - 1),
&pAsyncReqWrapper // ptr to ptr to request buffer
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiDevSpecific =
(PNDIS_TAPI_DEV_SPECIFIC)pAsyncReqWrapper->NdisTapiRequest.Data;
pNdisTapiDevSpecific->hdLine = pLine->hd_Line;
pNdisTapiDevSpecific->ulAddressID = dwAddressID;
if (hdCall)
{
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
FreeRequest(pAsyncReqWrapper);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiDevSpecific->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pAsyncReqWrapper);
return lRes;
}
}
else
{
pNdisTapiDevSpecific->hdCall = (HDRV_CALL)NULL;
}
pNdisTapiDevSpecific->ulParamsSize = dwSize;
CopyMemory(pNdisTapiDevSpecific->Params, lpParams, dwSize);
pAsyncReqWrapper->dwRequestSpecific = (DWORD_PTR)lpParams;
pAsyncReqWrapper->pfnPostProcess = TSPI_lineDevSpecific_postProcess;
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pAsyncReqWrapper);
if (pCall != NULL)
{
ReleaseObjReadLock((HANDLE)hdCall);
}
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineDial(
DRV_REQUESTID dwRequestID,
HDRVCALL hdCall,
LPCWSTR lpszDestAddress,
DWORD dwCountryCode
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
DWORD dwLength = lstrlenW (lpszDestAddress) + 1;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_DIAL pNdisTapiDial;
TspLog(DL_TRACE, "lineDial(%d): reqID(%x), call(%p)",
++dwSum, dwRequestID, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareAsyncRequest(
OID_TAPI_DIAL, // opcode
pCall->dwDeviceID, // device id
dwRequestID, // request id
sizeof(NDIS_TAPI_DIAL) + dwLength, // size of driver req buffer
&pAsyncReqWrapper // ptr to ptr to req buffer
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiDial =
(PNDIS_TAPI_DIAL)pAsyncReqWrapper->NdisTapiRequest.Data;
pNdisTapiDial->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pAsyncReqWrapper);
return lRes;
}
pNdisTapiDial->ulDestAddressSize = dwLength;
WideCharToMultiByte(CP_ACP, 0, lpszDestAddress,
-1, (LPSTR)pNdisTapiDial->szDestAddress,
dwLength, NULL, NULL);
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pAsyncReqWrapper);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
PASCAL
TSPI_lineDrop_postProcess(
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper,
LONG lRes,
PDWORD_PTR callStateMsgParams
)
{
BOOL bSendCallStateIdleMsg = FALSE;
LONG lSuc;
HDRVLINE hdLine;
HDRVCALL hdCall;
PDRVLINE pLine;
PDRVCALL pCall;
HTAPILINE htLine;
HTAPICALL htCall;
TspLog(DL_TRACE, "lineDrop_post: lRes(%x)", lRes);
hdCall = (HDRVCALL)(pAsyncReqWrapper->dwRequestSpecific);
lSuc = GetLineHandleFromCallHandle(hdCall, &hdLine);
if (lSuc != TAPI_SUCCESS)
{
return lSuc;
}
lSuc = GetLineObjWithReadLock(hdLine, &pLine);
if (lSuc != TAPI_SUCCESS)
{
return lSuc;
}
lSuc = GetCallObjWithWriteLock(hdCall, &pCall);
if (lSuc != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lSuc;
}
//
// @@@ Some old-style miniports, notably pcimac, don't indicate
// IDLE msgs when they get a drop request- so we synthesize this
// for them (only if and IDLE hasn't already been sent)
//
if (TAPI_SUCCESS == lRes)
{
ASSERT(INBOUND_CALL_KEY == pCall->dwKey ||
OUTBOUND_CALL_KEY == pCall->dwKey);
htCall = pCall->htCall;
htLine = pLine->htLine;
if (!pCall->bIdle)
{
pCall->bIdle = bSendCallStateIdleMsg = TRUE;
}
if (bSendCallStateIdleMsg)
{
TspLog(DL_INFO,
"postDrop::fnLineEvent(CALLSTATE_IDLE): htline(%p), htcall(%p)",
htLine, htCall);
(*gpfnLineEvent)(htLine,
htCall,
LINE_CALLSTATE,
LINECALLSTATE_IDLE,
0,
0);
}
}
ReleaseObjWriteLock((HANDLE)hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineDrop(
DRV_REQUESTID dwRequestID,
HDRVCALL hdCall,
LPCSTR lpsUserUserInfo,
DWORD dwSize
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_DROP pNdisTapiDrop;
HDRV_CALL NdisTapiHandle;
TspLog(DL_TRACE, "lineDrop(%d): reqID(%x), call(%p)",
++dwSum, dwRequestID, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
NdisTapiHandle = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
return lRes;
}
ReleaseObjReadLock((HANDLE)hdCall);
lRes = AcquireObjWriteLock((HANDLE)hdCall);
if (lRes != TAPI_SUCCESS) {
return lRes;
}
if ((lRes = PrepareAsyncRequest(
OID_TAPI_DROP, // opcode
pCall->dwDeviceID, // device id
dwRequestID, // request id
sizeof(NDIS_TAPI_DROP) + dwSize, // size of driver req buffer
&pAsyncReqWrapper // ptr to ptr to req buffer
)) != TAPI_SUCCESS)
{
ReleaseObjWriteLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiDrop =
(PNDIS_TAPI_DROP)pAsyncReqWrapper->NdisTapiRequest.Data;
pNdisTapiDrop->hdCall = NdisTapiHandle;
//
// @@@: the following is for legacy NDISWAN ISDN miniports
//
// Safely mark the call as dropped so the CloseCall code
// won't follow up with another "automatic" drop
//
pCall->bDropped = TRUE;
if ((pNdisTapiDrop->ulUserUserInfoSize = dwSize) != 0)
{
CopyMemory(pNdisTapiDrop->UserUserInfo, lpsUserUserInfo, dwSize);
}
pAsyncReqWrapper->dwRequestSpecific = (DWORD_PTR)hdCall;
pAsyncReqWrapper->pfnPostProcess = TSPI_lineDrop_postProcess;
ReleaseObjWriteLock((HANDLE)hdCall);
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pAsyncReqWrapper);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetAddressCaps(
DWORD dwDeviceID,
DWORD dwAddressID,
DWORD dwTSPIVersion,
DWORD dwExtVersion,
LPLINEADDRESSCAPS lpAddressCaps
)
{
static DWORD dwSum = 0;
LONG lRes;
PNDISTAPI_REQUEST pNdisTapiRequest;
PLINE_ADDRESS_CAPS pCaps;
PNDIS_TAPI_GET_ADDRESS_CAPS pNdisTapiGetAddressCaps;
TspLog(DL_TRACE,
"lineGetAddressCaps(%d): deviceID(%x), addressID(%x), "\
"TSPIV(%x), ExtV(%x)",
++dwSum, dwDeviceID, dwAddressID);
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_ADDRESS_CAPS, // opcode
dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_ADDRESS_CAPS) + // size of req data
(lpAddressCaps->dwTotalSize - sizeof(LINE_ADDRESS_CAPS)),
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
return lRes;
}
pNdisTapiGetAddressCaps =
(PNDIS_TAPI_GET_ADDRESS_CAPS)pNdisTapiRequest->Data;
pNdisTapiGetAddressCaps->ulDeviceID = dwDeviceID;
pNdisTapiGetAddressCaps->ulAddressID = dwAddressID;
pNdisTapiGetAddressCaps->ulExtVersion = dwExtVersion;
pCaps = &pNdisTapiGetAddressCaps->LineAddressCaps;
pCaps->ulTotalSize = lpAddressCaps->dwTotalSize;
pCaps->ulNeededSize = pCaps->ulUsedSize = sizeof (LINE_ADDRESS_CAPS);
ZeroMemory(
&pCaps->ulLineDeviceID,
sizeof(LINE_ADDRESS_CAPS) - 3 * sizeof(ULONG)
);
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
return lRes;
}
//
// Do some post processing to the returned data structure
// before passing it back to tapi:
// 1. Pad the area between the fixed 1.0 structure and the
// var data that the miniports pass back with 0's so a
// bad app that disregards the 1.0 version negotiation &
// references new 1.4 or 2.0 structure fields won't blow up
// 2. Convert ascii strings to unicode, & rebase all var data
//
//
// The real needed size is the sum of that requested by the
// underlying driver, plus padding for the new TAPI 1.4/2.0
// structure fields, plus the size of the var data returned
// by the driver to account for the ascii->unicode conversion.
// @@@ Granted, we are very liberal in computing the value for
// this last part, but at least this way it's fast & we'll
// never have too little buffer space.
//
lpAddressCaps->dwNeededSize =
pCaps->ulNeededSize +
(sizeof(LINEADDRESSCAPS) - // v2.0 struct
sizeof(LINE_ADDRESS_CAPS)) + // v1.0 struct
(pCaps->ulNeededSize - sizeof(LINE_ADDRESS_CAPS));
//
// Copy over the fixed fields that don't need changing, i.e.
// everything from dwAddressSharing to dwCallCompletionModes
//
lpAddressCaps->dwLineDeviceID = dwDeviceID;
CopyMemory(
&lpAddressCaps->dwAddressSharing,
&pCaps->ulAddressSharing,
sizeof(LINE_ADDRESS_CAPS) - (12 * sizeof(DWORD))
);
if (lpAddressCaps->dwNeededSize > lpAddressCaps->dwTotalSize)
{
lpAddressCaps->dwUsedSize =
(lpAddressCaps->dwTotalSize < sizeof(LINEADDRESSCAPS) ?
lpAddressCaps->dwTotalSize : sizeof(LINEADDRESSCAPS));
}
else
{
lpAddressCaps->dwUsedSize = sizeof(LINEADDRESSCAPS); // v2.0 struct
INSERTVARDATASTRING(
pCaps,
&pCaps->ulAddressSize,
lpAddressCaps,
&lpAddressCaps->dwAddressSize,
sizeof(LINE_ADDRESS_CAPS),
"LINE_ADDRESS_CAPS.Address"
);
INSERTVARDATA(
pCaps,
&pCaps->ulDevSpecificSize,
lpAddressCaps,
&lpAddressCaps->dwDevSpecificSize,
sizeof(LINE_ADDRESS_CAPS),
"LINE_ADDRESS_CAPS.DevSpecific"
);
if (pCaps->ulCompletionMsgTextSize != 0)
{
// @@@ convert ComplMsgText to unicode???
INSERTVARDATA(
pCaps,
&pCaps->ulCompletionMsgTextSize,
lpAddressCaps,
&lpAddressCaps->dwCompletionMsgTextSize,
sizeof (LINE_ADDRESS_CAPS),
"LINE_ADDRESS_CAPS.CompletionMsgText"
);
lpAddressCaps->dwNumCompletionMessages =
pCaps->ulNumCompletionMessages;
lpAddressCaps->dwCompletionMsgTextEntrySize =
pCaps->ulCompletionMsgTextEntrySize;
}
// make sure dwNeededSize == dwUsedSize
lpAddressCaps->dwNeededSize = lpAddressCaps->dwUsedSize;
}
FreeRequest(pNdisTapiRequest);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetAddressID(
HDRVLINE hdLine,
LPDWORD lpdwAddressID,
DWORD dwAddressMode,
LPCWSTR lpsAddress,
DWORD dwSize
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_GET_ADDRESS_ID pNdisTapiGetAddressID;
TspLog(DL_TRACE, "lineGetAddressID(%d): line(%p), addressMode(%x)",
++dwSum, hdLine, dwAddressMode);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_ADDRESS_ID, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_ADDRESS_ID) + // size of req data
dwSize / 2 - 1,
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiGetAddressID = (PNDIS_TAPI_GET_ADDRESS_ID)pNdisTapiRequest->Data;
pNdisTapiGetAddressID->hdLine = pLine->hd_Line;
pNdisTapiGetAddressID->ulAddressMode = dwAddressMode;
pNdisTapiGetAddressID->ulAddressSize = dwSize / 2;
WideCharToMultiByte(CP_ACP, 0, lpsAddress, dwSize,
(LPSTR)pNdisTapiGetAddressID->szAddress, dwSize / 2, NULL, NULL);
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
*lpdwAddressID = pNdisTapiGetAddressID->ulAddressID;
TspLog(DL_INFO, "lineGetAddressID: addressID(%x)", *lpdwAddressID);
}
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetAddressStatus(
HDRVLINE hdLine,
DWORD dwAddressID,
LPLINEADDRESSSTATUS lpAddressStatus
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PLINE_ADDRESS_STATUS pStatus;
PNDIS_TAPI_GET_ADDRESS_STATUS pNdisTapiGetAddressStatus;
TspLog(DL_TRACE, "lineGetAddressStatus(%d): line(%p), addressID(%x)",
++dwSum, hdLine, dwAddressID);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_ADDRESS_STATUS, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_ADDRESS_STATUS) + // size of req data
(lpAddressStatus->dwTotalSize - sizeof(LINE_ADDRESS_STATUS)),
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiGetAddressStatus =
(PNDIS_TAPI_GET_ADDRESS_STATUS)pNdisTapiRequest->Data;
pNdisTapiGetAddressStatus->hdLine = pLine->hd_Line;
pNdisTapiGetAddressStatus->ulAddressID = dwAddressID;
pStatus = &pNdisTapiGetAddressStatus->LineAddressStatus;
pStatus->ulTotalSize = lpAddressStatus->dwTotalSize;
pStatus->ulNeededSize = pStatus->ulUsedSize = sizeof(LINE_ADDRESS_STATUS);
ZeroMemory(&pStatus->ulNumInUse,
sizeof(LINE_ADDRESS_STATUS) - 3 * sizeof(ULONG));
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
CopyMemory(
lpAddressStatus,
&pNdisTapiGetAddressStatus->LineAddressStatus,
pNdisTapiGetAddressStatus->LineAddressStatus.ulUsedSize
);
}
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetCallAddressID(
HDRVCALL hdCall,
LPDWORD lpdwAddressID
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_GET_CALL_ADDRESS_ID pNdisTapiGetCallAddressID;
TspLog(DL_TRACE, "lineGetCallAddressID(%d): call(%p)", ++dwSum, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_CALL_ADDRESS_ID, // opcode
pCall->dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_CALL_ADDRESS_ID), // size of req data
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiGetCallAddressID =
(PNDIS_TAPI_GET_CALL_ADDRESS_ID)pNdisTapiRequest->Data;
pNdisTapiGetCallAddressID->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
return lRes;
}
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
*lpdwAddressID = pNdisTapiGetCallAddressID->ulAddressID;
TspLog(DL_INFO, "lineGetCallAddressID: addressID(%x)", *lpdwAddressID);
}
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetCallInfo(
HDRVCALL hdCall,
LPLINECALLINFO lpCallInfo
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PNDISTAPI_REQUEST pNdisTapiRequest;
PLINE_CALL_INFO pInfo;
PNDIS_TAPI_GET_CALL_INFO pNdisTapiGetCallInfo;
TspLog(DL_TRACE, "lineGetCallInfo(%d): call(%p)", ++dwSum, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_CALL_INFO, // opcode
pCall->dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_CALL_INFO) + // size of req data
(lpCallInfo->dwTotalSize - sizeof(LINE_CALL_INFO)),
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiGetCallInfo = (PNDIS_TAPI_GET_CALL_INFO)pNdisTapiRequest->Data;
pNdisTapiGetCallInfo->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
return lRes;
}
pInfo = &pNdisTapiGetCallInfo->LineCallInfo;
pInfo->ulTotalSize = lpCallInfo->dwTotalSize;
pInfo->ulNeededSize = pInfo->ulUsedSize = sizeof(LINE_CALL_INFO);
ZeroMemory(&pInfo->hLine, sizeof(LINE_CALL_INFO) - 3 * sizeof(ULONG));
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
//
// Do some post processing to the returned data structure
// before passing it back to tapi:
// 1. Pad the area between the fixed 1.0 structure and the
// var data that the miniports pass back with 0's so a
// bad app that disregards the 1.0 version negotiation &
// references new 1.4 or 2.0 structure fields won't blow up
// 2. Convert ascii strings to unicode, & rebase all var data
//
//
// The real needed size is the sum of that requested by the
// underlying driver, plus padding for the new TAPI 1.4/2.0
// structure fields, plus the size of the var data returned
// by the driver to account for the ascii->unicode conversion.
// @@@ Granted, we are very liberal in computing the value for
// this last part, but at least this way it's fast & we'll
// never have too little buffer space.
//
lpCallInfo->dwNeededSize =
pInfo->ulNeededSize +
(sizeof(LINECALLINFO) - // v2.0 struct
sizeof(LINE_CALL_INFO)) + // v1.0 struct
(pInfo->ulNeededSize - sizeof(LINE_CALL_INFO));
//
// Copy over the fixed fields that don't need changing,
// i.e. everything from dwLineDeviceID to dwTrunk
//
CopyMemory(
&lpCallInfo->dwLineDeviceID,
&pInfo->ulLineDeviceID,
23 * sizeof(DWORD)
);
if (lpCallInfo->dwNeededSize > lpCallInfo->dwTotalSize)
{
lpCallInfo->dwUsedSize =
(lpCallInfo->dwTotalSize < sizeof(LINECALLINFO) ?
lpCallInfo->dwTotalSize : sizeof(LINECALLINFO));
}
else
{
lpCallInfo->dwUsedSize = sizeof(LINECALLINFO); // v2.0 struct
lpCallInfo->dwCallerIDFlags = pInfo->ulCallerIDFlags;
INSERTVARDATASTRING(
pInfo,
&pInfo->ulCallerIDSize,
lpCallInfo,
&lpCallInfo->dwCallerIDSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.CallerID"
);
INSERTVARDATASTRING(
pInfo,
&pInfo->ulCallerIDNameSize,
lpCallInfo,
&lpCallInfo->dwCallerIDNameSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.CallerIDName"
);
lpCallInfo->dwCalledIDFlags = pInfo->ulCalledIDFlags;
INSERTVARDATASTRING(
pInfo,
&pInfo->ulCalledIDSize,
lpCallInfo,
&lpCallInfo->dwCalledIDSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.CalledID"
);
INSERTVARDATASTRING(
pInfo,
&pInfo->ulCalledIDNameSize,
lpCallInfo,
&lpCallInfo->dwCalledIDNameSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.CalledIDName"
);
lpCallInfo->dwConnectedIDFlags = pInfo->ulConnectedIDFlags;
INSERTVARDATASTRING(
pInfo,
&pInfo->ulConnectedIDSize,
lpCallInfo,
&lpCallInfo->dwConnectedIDSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.ConnectID"
);
INSERTVARDATASTRING(
pInfo,
&pInfo->ulConnectedIDNameSize,
lpCallInfo,
&lpCallInfo->dwConnectedIDNameSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.ConnectIDName"
);
lpCallInfo->dwRedirectionIDFlags = pInfo->ulRedirectionIDFlags;
INSERTVARDATASTRING(
pInfo,
&pInfo->ulRedirectionIDSize,
lpCallInfo,
&lpCallInfo->dwRedirectionIDSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.RedirectionID"
);
INSERTVARDATASTRING(
pInfo,
&pInfo->ulRedirectionIDNameSize,
lpCallInfo,
&lpCallInfo->dwRedirectionIDNameSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.RedirectionIDName"
);
lpCallInfo->dwRedirectingIDFlags = pInfo->ulRedirectingIDFlags;
INSERTVARDATASTRING(
pInfo,
&pInfo->ulRedirectingIDSize,
lpCallInfo,
&lpCallInfo->dwRedirectingIDSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.RedirectingID"
);
INSERTVARDATASTRING(
pInfo,
&pInfo->ulRedirectingIDNameSize,
lpCallInfo,
&lpCallInfo->dwRedirectingIDNameSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.RedirectingIDName"
);
INSERTVARDATA(
pInfo,
&pInfo->ulDisplaySize,
lpCallInfo,
&lpCallInfo->dwDisplaySize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.Display"
);
INSERTVARDATA(
pInfo,
&pInfo->ulUserUserInfoSize,
lpCallInfo,
&lpCallInfo->dwUserUserInfoSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.UserUserInfo"
);
INSERTVARDATA(
pInfo,
&pInfo->ulHighLevelCompSize,
lpCallInfo,
&lpCallInfo->dwHighLevelCompSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.HighLevelComp"
);
INSERTVARDATA(
pInfo,
&pInfo->ulLowLevelCompSize,
lpCallInfo,
&lpCallInfo->dwLowLevelCompSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.LowLevelComp"
);
INSERTVARDATA(
pInfo,
&pInfo->ulChargingInfoSize,
lpCallInfo,
&lpCallInfo->dwChargingInfoSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.ChargingInfo"
);
INSERTVARDATA(
pInfo,
&pInfo->ulTerminalModesSize,
lpCallInfo,
&lpCallInfo->dwTerminalModesSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.TerminalModes"
);
INSERTVARDATA(
pInfo,
&pInfo->ulDevSpecificSize,
lpCallInfo,
&lpCallInfo->dwDevSpecificSize,
sizeof(LINE_CALL_INFO),
"LINE_CALL_INFO.DevSpecific"
);
// make sure that dwNeededSize == dwUsedSize
lpCallInfo->dwNeededSize = lpCallInfo->dwUsedSize;
}
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetCallStatus(
HDRVCALL hdCall,
LPLINECALLSTATUS lpCallStatus
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PNDISTAPI_REQUEST pNdisTapiRequest;
PLINE_CALL_STATUS pStatus;
PNDIS_TAPI_GET_CALL_STATUS pNdisTapiGetCallStatus;
TspLog(DL_TRACE, "lineGetCallStatus(%d): call(%p)", ++dwSum, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_CALL_STATUS, // opcode
pCall->dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_CALL_STATUS) + // size of req data
(lpCallStatus->dwTotalSize - sizeof(LINE_CALL_STATUS)),
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiGetCallStatus = (PNDIS_TAPI_GET_CALL_STATUS)pNdisTapiRequest->Data;
pNdisTapiGetCallStatus->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
return lRes;
}
pStatus = &pNdisTapiGetCallStatus->LineCallStatus;
pStatus->ulTotalSize = lpCallStatus->dwTotalSize;
pStatus->ulNeededSize = pStatus->ulUsedSize = sizeof(LINE_CALL_STATUS);
ZeroMemory(&pStatus->ulCallState,
sizeof(LINE_CALL_STATUS) - 3 * sizeof(ULONG));
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
//
// Do some post processing to the returned data structure
// before passing it back to tapi:
// 1. Pad the area between the fixed 1.0 structure and the
// var data that the miniports pass back with 0's so a
// bad app that disregards the 1.0 version negotiation &
// references new 1.4 or 2.0 structure fields won't blow up
// (no embedded ascii strings to convert to unicode)
//
//
// The real needed size is the sum of that requested by the
// underlying driver, plus padding for the new TAPI 1.4/2.0
// structure fields. (There are no embedded ascii strings to
// convert to unicode, so no extra space needed for that.)
//
lpCallStatus->dwNeededSize =
pStatus->ulNeededSize +
(sizeof(LINECALLSTATUS) - // v2.0 struct
sizeof(LINE_CALL_STATUS)); // v1.0 struct
//
// Copy over the fixed fields that don't need changing,
// i.e. everything from dwLineDeviceID to dwCallCompletionModes
//
CopyMemory(
&lpCallStatus->dwCallState,
&pStatus->ulCallState,
4 * sizeof(DWORD)
);
if (lpCallStatus->dwNeededSize > lpCallStatus->dwTotalSize)
{
lpCallStatus->dwUsedSize =
(lpCallStatus->dwTotalSize < sizeof(LINECALLSTATUS) ?
lpCallStatus->dwTotalSize : sizeof(LINECALLSTATUS));
}
else
{
lpCallStatus->dwUsedSize = sizeof(LINECALLSTATUS);
// v2.0 struct
INSERTVARDATA(
pStatus,
&pStatus->ulDevSpecificSize,
lpCallStatus,
&lpCallStatus->dwDevSpecificSize,
sizeof(LINE_CALL_STATUS),
"LINE_CALL_STATUS.DevSpecific"
);
}
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LINEDEVCAPS *
GetLineDevCaps(
IN DWORD dwDeviceID,
IN DWORD dwExtVersion
)
{
LONG lRes;
PNDISTAPI_REQUEST pNdisTapiRequest;
PLINE_DEV_CAPS pCaps;
PNDIS_TAPI_GET_DEV_CAPS pNdisTapiGetDevCaps;
DWORD dwNeededSize;
LINEDEVCAPS *pLineDevCaps;
DWORD dwTotalSize = sizeof(LINEDEVCAPS) + 0x80;
get_caps:
pLineDevCaps = (LINEDEVCAPS *)MALLOC(dwTotalSize);
if (NULL == pLineDevCaps)
{
TspLog(DL_ERROR, "GetLineDevCaps: failed to alloc mem of size(%x)",
dwTotalSize);
return NULL;
}
pLineDevCaps->dwTotalSize = dwTotalSize;
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_DEV_CAPS, // opcode
dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_DEV_CAPS) + // size of req data
(dwTotalSize - sizeof(LINE_DEV_CAPS)),
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
return NULL;
}
pNdisTapiGetDevCaps = (PNDIS_TAPI_GET_DEV_CAPS)pNdisTapiRequest->Data;
pNdisTapiGetDevCaps->ulDeviceID = dwDeviceID;
pNdisTapiGetDevCaps->ulExtVersion = dwExtVersion;
pCaps = &pNdisTapiGetDevCaps->LineDevCaps;
pCaps->ulTotalSize = dwTotalSize;
pCaps->ulNeededSize = pCaps->ulUsedSize = sizeof(LINE_DEV_CAPS);
ZeroMemory(&pCaps->ulProviderInfoSize,
sizeof(LINE_DEV_CAPS) - 3 * sizeof(ULONG));
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
return NULL;
}
//
// The real needed size is the sum of that requested by the
// underlying driver, plus padding for the new TAPI 1.4/2.0
// structure fields, plus the size of the var data returned
// by the driver to account for the ascii->unicode conversion.
// @@@ Granted, we are very liberal in computing the value for
// this last part, but at least this way it's fast & we'll
// never have too little buffer space.
//
TspLog(DL_TRACE,
"GetLineDevCaps: ulNeeded(%x), LINEDEVCAPS(%x), LINE_DEV_CAPS(%x)",
pCaps->ulNeededSize, sizeof(LINEDEVCAPS), sizeof(LINE_DEV_CAPS));
dwNeededSize =
pCaps->ulNeededSize +
(sizeof(LINEDEVCAPS) - // v2.0 struct
sizeof(LINE_DEV_CAPS)) + // v1.0 struct
(pCaps->ulNeededSize - sizeof(LINE_DEV_CAPS));
TspLog(DL_TRACE, "GetLineDevCaps: dwNeededSize(%x), dwTotalSize(%x)",
dwNeededSize, dwTotalSize);
if (dwNeededSize > dwTotalSize)
{
// free up the old req
FreeRequest(pNdisTapiRequest);
// free the old buffer
FREE(pLineDevCaps);
// try again with a larger buffer
dwTotalSize = dwNeededSize;
goto get_caps;
}
ASSERT(dwNeededSize <= dwTotalSize);
//
// Copy over the fixed fields that don't need changing,
// i.e. everything from dwPermanentLineID to dwNumTerminals
//
CopyMemory(
&pLineDevCaps->dwPermanentLineID,
&pCaps->ulPermanentLineID,
sizeof(LINE_DEV_CAPS) - (14 * sizeof(DWORD))
);
// set the local flag to indicate that
// the line can't be used from remote machine
pLineDevCaps->dwDevCapFlags |= LINEDEVCAPFLAGS_LOCAL;
//
// Do some post processing to the returned data structure
// before passing it back to tapi:
// 1. Pad the area between the fixed 1.0 structure and the
// var data that the miniports pass back with 0's so a
// bad app that disregards the 1.0 version negotiation &
// references new 1.4 or 2.0 structure fields won't blow up
// 2. Convert ascii strings to unicode, & rebase all var data
//
pLineDevCaps->dwUsedSize = sizeof(LINEDEVCAPS); // v2.0 struct
INSERTVARDATASTRING(
pCaps,
&pCaps->ulProviderInfoSize,
pLineDevCaps,
&pLineDevCaps->dwProviderInfoSize,
sizeof(LINE_DEV_CAPS),
"LINE_DEV_CAPS.ProviderInfo"
);
INSERTVARDATASTRING(
pCaps,
&pCaps->ulSwitchInfoSize,
pLineDevCaps,
&pLineDevCaps->dwSwitchInfoSize,
sizeof(LINE_DEV_CAPS),
"LINE_DEV_CAPS.SwitchInfo"
);
INSERTVARDATASTRING(
pCaps,
&pCaps->ulLineNameSize,
pLineDevCaps,
&pLineDevCaps->dwLineNameSize,
sizeof(LINE_DEV_CAPS),
"LINE_DEV_CAPS.LineName"
);
INSERTVARDATA(
pCaps,
&pCaps->ulTerminalCapsSize,
pLineDevCaps,
&pLineDevCaps->dwTerminalCapsSize,
sizeof(LINE_DEV_CAPS),
"LINE_DEV_CAPS.TerminalCaps"
);
// @@@ convert DevCaps.TermText to unicode???
pLineDevCaps->dwTerminalTextEntrySize =
pCaps->ulTerminalTextEntrySize;
INSERTVARDATA(
pCaps,
&pCaps->ulTerminalTextSize,
pLineDevCaps,
&pLineDevCaps->dwTerminalTextSize,
sizeof(LINE_DEV_CAPS),
"LINE_DEV_CAPS.TerminalText"
);
INSERTVARDATA(
pCaps,
&pCaps->ulDevSpecificSize,
pLineDevCaps,
&pLineDevCaps->dwDevSpecificSize,
sizeof(LINE_DEV_CAPS),
"LINE_DEV_CAPS.DevSpecific"
);
// make sure dwNeededSize == dwUsedSize
pLineDevCaps->dwNeededSize = pLineDevCaps->dwUsedSize;
FreeRequest(pNdisTapiRequest);
return pLineDevCaps;
}
LONG
TSPIAPI
TSPI_lineGetDevCaps(
DWORD dwDeviceID,
DWORD dwTSPIVersion,
DWORD dwExtVersion,
LPLINEDEVCAPS lpLineDevCaps
)
{
static DWORD dwSum = 0;
LONG lRes;
TspLog(DL_TRACE, "lineGetDevCaps(%d): deviceID(%x), TSPIV(%x), ExtV(%x)",
++dwSum, dwDeviceID, dwTSPIVersion, dwExtVersion);
lRes = GetDevCaps(dwDeviceID, dwTSPIVersion, dwExtVersion, lpLineDevCaps);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetDevConfig(
DWORD dwDeviceID,
LPVARSTRING lpDeviceConfig,
LPCWSTR lpszDeviceClass
)
{
static DWORD dwSum = 0;
LONG lRes;
DWORD dwLength = lstrlenW (lpszDeviceClass) + 1;
PNDISTAPI_REQUEST pNdisTapiRequest;
PVAR_STRING pConfig;
PNDIS_TAPI_GET_DEV_CONFIG pNdisTapiGetDevConfig;
TspLog(DL_TRACE, "lineGetDevConfig(%d): deviceID(%x)", ++dwSum, dwDeviceID);
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_DEV_CONFIG, // opcode
dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_DEV_CONFIG) + // size of req data
(lpDeviceConfig->dwTotalSize - sizeof(VAR_STRING)) + dwLength,
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
return lRes;
}
pNdisTapiGetDevConfig = (PNDIS_TAPI_GET_DEV_CONFIG)pNdisTapiRequest->Data;
pNdisTapiGetDevConfig->ulDeviceID = dwDeviceID;
pNdisTapiGetDevConfig->ulDeviceClassSize = dwLength;
pNdisTapiGetDevConfig->ulDeviceClassOffset =
sizeof(NDIS_TAPI_GET_DEV_CONFIG) +
(lpDeviceConfig->dwTotalSize - sizeof(VAR_STRING));
pConfig = &pNdisTapiGetDevConfig->DeviceConfig;
pConfig->ulTotalSize = lpDeviceConfig->dwTotalSize;
pConfig->ulNeededSize = pConfig->ulUsedSize = sizeof(VAR_STRING);
pConfig->ulStringFormat =
pConfig->ulStringSize =
pConfig->ulStringOffset = 0;
// NOTE: old miniports expect strings to be ascii
WideCharToMultiByte(CP_ACP, 0, lpszDeviceClass, -1,
(LPSTR) (((LPBYTE) pNdisTapiGetDevConfig) +
pNdisTapiGetDevConfig->ulDeviceClassOffset),
dwLength, NULL, NULL);
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
CopyMemory(
lpDeviceConfig,
&pNdisTapiGetDevConfig->DeviceConfig,
pNdisTapiGetDevConfig->DeviceConfig.ulUsedSize
);
}
FreeRequest(pNdisTapiRequest);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetExtensionID(
DWORD dwDeviceID,
DWORD dwTSPIVersion,
LPLINEEXTENSIONID lpExtensionID
)
{
static DWORD dwSum = 0;
LONG lRes;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_GET_EXTENSION_ID pNdisTapiGetExtensionID;
TspLog(DL_TRACE, "lineGetExtensionID(%d): deviceID(%x), TSPIV(%x)",
++dwSum, dwDeviceID, dwTSPIVersion);
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_EXTENSION_ID, // opcode
dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_EXTENSION_ID), // size of req data
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
return lRes;
}
pNdisTapiGetExtensionID =
(PNDIS_TAPI_GET_EXTENSION_ID)pNdisTapiRequest->Data;
pNdisTapiGetExtensionID->ulDeviceID = dwDeviceID;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
CopyMemory(
lpExtensionID,
&pNdisTapiGetExtensionID->LineExtensionID,
sizeof(LINE_EXTENSION_ID)
);
}
else
{
//
// Rather than indicating a failure, we'll just zero out the
// ext id (implying driver doesn't support extensions) and
// return success to tapisrv so it'll complete the open ok
//
ZeroMemory(lpExtensionID, sizeof(LINE_EXTENSION_ID));
lRes = TAPI_SUCCESS;
}
FreeRequest(pNdisTapiRequest);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetID(
HDRVLINE hdLine,
DWORD dwAddressID,
HDRVCALL hdCall,
DWORD dwSelect,
LPVARSTRING lpDeviceID,
LPCWSTR lpszDeviceClass,
HANDLE hTargetProcess
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine = NULL;
PDRVCALL pCall = NULL;
PNDISTAPI_REQUEST pNdisTapiRequest;
DWORD dwLength = lstrlenW(lpszDeviceClass) + 1;
DWORD dwDeviceID;
PUCHAR pchDest;
PVAR_STRING pID;
PNDIS_TAPI_GET_ID pNdisTapiGetID;
TspLog(DL_TRACE,
"lineGetID(%d): line(%p), call(%p), addressID(%x), select(%x)",
++dwSum, hdLine, hdCall, dwAddressID, dwSelect);
ASSERT(LINECALLSELECT_LINE == dwSelect ||
LINECALLSELECT_ADDRESS == dwSelect ||
LINECALLSELECT_CALL == dwSelect);
if (LINECALLSELECT_LINE == dwSelect ||
LINECALLSELECT_ADDRESS == dwSelect)
{
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
}
if (LINECALLSELECT_CALL == dwSelect)
{
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
}
//
// Kmddsp will field this specific call on behalf of the
// wan miniports. It returns the guid and media string
// of the adapter that this line lives on
//
if (LINECALLSELECT_LINE == dwSelect &&
!wcscmp(lpszDeviceClass, L"LineGuid"))
{
lpDeviceID->dwNeededSize =
sizeof(VARSTRING) + sizeof(GUID) +
sizeof(pLine->MediaType) + sizeof('\0');
if (lpDeviceID->dwTotalSize < lpDeviceID->dwNeededSize)
{
if (pCall != NULL)
{
ReleaseObjReadLock((HANDLE)hdCall);
}
if (pLine != NULL)
{
ReleaseObjReadLock((HANDLE)hdLine);
}
return LINEERR_STRUCTURETOOSMALL;
}
lpDeviceID->dwUsedSize = lpDeviceID->dwNeededSize;
lpDeviceID->dwStringFormat = STRINGFORMAT_ASCII;
pchDest = (PUCHAR)lpDeviceID + sizeof(*lpDeviceID);
lpDeviceID->dwStringOffset = (DWORD)(pchDest - (PUCHAR)lpDeviceID);
lpDeviceID->dwStringSize =
sizeof(GUID) + sizeof(pLine->MediaType) +sizeof('\0');
MoveMemory(
pchDest,
(PUCHAR)&pLine->Guid,
sizeof(pLine->Guid)
);
pchDest += sizeof(pLine->Guid);
MoveMemory(
pchDest,
&pLine->MediaType,
sizeof(pLine->MediaType)
);
pchDest += sizeof(pLine->MediaType);
*pchDest = '\0';
TspLog(DL_INFO, "lineGetID: obj(%p)", hdLine);
TspLog(
DL_INFO,
"Guid %4.4x-%2.2x-%2.2x-%1.1x%1.1x-%1.1x%1.1x%1.1x%1.1x%1.1x%1.1x",
pLine->Guid.Data1, pLine->Guid.Data2,
pLine->Guid.Data3, pLine->Guid.Data4[0],
pLine->Guid.Data4[1], pLine->Guid.Data4[2],
pLine->Guid.Data4[3], pLine->Guid.Data4[4],
pLine->Guid.Data4[5], pLine->Guid.Data4[6],
pLine->Guid.Data4[7]
);
TspLog(DL_INFO, "MediaType: %d", pLine->MediaType);
if (pCall != NULL)
{
ReleaseObjReadLock((HANDLE)hdCall);
}
if (pLine != NULL)
{
ReleaseObjReadLock((HANDLE)hdLine);
}
return TAPI_SUCCESS;
}
dwDeviceID = (LINECALLSELECT_CALL == dwSelect) ?
pCall->dwDeviceID : pLine->dwDeviceID;
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_ID, // opcode
dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_ID) + // size of req data
(lpDeviceID->dwTotalSize - sizeof(VAR_STRING)) + dwLength,
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
if (pCall != NULL)
{
ReleaseObjReadLock((HANDLE)hdCall);
}
if (pLine != NULL)
{
ReleaseObjReadLock((HANDLE)hdLine);
}
return lRes;
}
pNdisTapiGetID = (PNDIS_TAPI_GET_ID)pNdisTapiRequest->Data;
if (LINECALLSELECT_LINE == dwSelect ||
LINECALLSELECT_ADDRESS == dwSelect)
{
pNdisTapiGetID->hdLine = pLine->hd_Line;
}
pNdisTapiGetID->ulAddressID = dwAddressID;
if (LINECALLSELECT_CALL == dwSelect)
{
pNdisTapiGetID->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
if(pLine != NULL)
{
ReleaseObjReadLock((HANDLE) hdLine);
}
return lRes;
}
}
pNdisTapiGetID->ulSelect = dwSelect;
pNdisTapiGetID->ulDeviceClassSize = dwLength;
pNdisTapiGetID->ulDeviceClassOffset = sizeof(NDIS_TAPI_GET_ID) +
(lpDeviceID->dwTotalSize - sizeof(VAR_STRING));
pID = &pNdisTapiGetID->DeviceID;
pID->ulTotalSize = lpDeviceID->dwTotalSize;
pID->ulNeededSize = pID->ulUsedSize = sizeof(VAR_STRING);
pID->ulStringFormat = pID->ulStringSize = pID->ulStringOffset = 0;
// NOTE: old miniports expect strings to be ascii
WideCharToMultiByte(
CP_ACP, 0, lpszDeviceClass, -1,
(LPSTR) (((LPBYTE) pNdisTapiGetID) +
pNdisTapiGetID->ulDeviceClassOffset),
dwLength, NULL, NULL);
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
CopyMemory(
lpDeviceID,
&pNdisTapiGetID->DeviceID,
pNdisTapiGetID->DeviceID.ulUsedSize
);
}
FreeRequest(pNdisTapiRequest);
if (pCall != NULL)
{
ReleaseObjReadLock((HANDLE)hdCall);
}
if (pLine != NULL)
{
ReleaseObjReadLock((HANDLE)hdLine);
}
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetLineDevStatus(
HDRVLINE hdLine,
LPLINEDEVSTATUS lpLineDevStatus
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PLINE_DEV_STATUS pStatus;
PNDIS_TAPI_GET_LINE_DEV_STATUS pNdisTapiGetLineDevStatus;
TspLog(DL_TRACE, "lineGetLineDevStatus(%d): line(%p)", ++dwSum, hdLine);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_GET_LINE_DEV_STATUS, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_GET_LINE_DEV_STATUS) + // size of req data
(lpLineDevStatus->dwTotalSize - sizeof(LINE_DEV_STATUS)),
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiGetLineDevStatus =
(PNDIS_TAPI_GET_LINE_DEV_STATUS)pNdisTapiRequest->Data;
pNdisTapiGetLineDevStatus->hdLine = pLine->hd_Line;
pStatus = &pNdisTapiGetLineDevStatus->LineDevStatus;
pStatus->ulTotalSize = lpLineDevStatus->dwTotalSize;
pStatus->ulNeededSize = pStatus->ulUsedSize = sizeof(LINE_DEV_STATUS);
ZeroMemory(&pStatus->ulNumOpens,
sizeof(LINE_DEV_STATUS) - 3 * sizeof(ULONG));
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
//
// Do some post processing to the returned data structure
// before passing it back to tapi:
// 1. Pad the area between the fixed 1.0 structure and the
// var data that the miniports pass back with 0's so a
// bad app that disregards the 1.0 version negotiation &
// references new 1.4 or 2.0 structure fields won't blow up
// (no embedded ascii strings to convert to unicode)
//
//
// The real needed size is the sum of that requested by the
// underlying driver, plus padding for the new TAPI 1.4/2.0
// structure fields. (There are no embedded ascii strings to
// convert to unicode, so no extra space needed for that.)
//
lpLineDevStatus->dwNeededSize =
pStatus->ulNeededSize +
(sizeof(LINEDEVSTATUS) - // v2.0 struct
sizeof(LINE_DEV_STATUS)); // v1.0 struct
//
// Copy over the fixed fields that don't need changing,
// i.e. everything from dwNumActiveCalls to dwDevStatusFlags
//
CopyMemory(
&lpLineDevStatus->dwNumActiveCalls,
&pStatus->ulNumActiveCalls,
sizeof(LINE_DEV_STATUS) - (9 * sizeof(DWORD))
);
if (lpLineDevStatus->dwNeededSize > lpLineDevStatus->dwTotalSize)
{
lpLineDevStatus->dwUsedSize =
(lpLineDevStatus->dwTotalSize < sizeof(LINEDEVSTATUS) ?
lpLineDevStatus->dwTotalSize : sizeof(LINEDEVSTATUS));
}
else
{
lpLineDevStatus->dwUsedSize = sizeof(LINEDEVSTATUS);
// v2.0 struct
INSERTVARDATA(
pStatus,
&pStatus->ulTerminalModesSize,
lpLineDevStatus,
&lpLineDevStatus->dwTerminalModesSize,
sizeof(LINE_DEV_STATUS),
"LINE_DEV_STATUS.TerminalModes"
);
INSERTVARDATA(
pStatus,
&pStatus->ulDevSpecificSize,
lpLineDevStatus,
&lpLineDevStatus->dwDevSpecificSize,
sizeof(LINE_DEV_STATUS),
"LINE_DEV_STATUS.DevSpecific"
);
}
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineGetNumAddressIDs(
HDRVLINE hdLine,
LPDWORD lpdwNumAddressIDs
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
TspLog(DL_TRACE, "lineGetNumAddressIDs(%d): line(%p)", ++dwSum, hdLine);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
lRes = GetNumAddressIDs(pLine->dwDeviceID, lpdwNumAddressIDs);
if (TAPI_SUCCESS == lRes)
{
TspLog(DL_INFO, "lineGetNumAddressIDs: numAddressIDs(%x)",
*lpdwNumAddressIDs);
}
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
PASCAL
TSPI_lineMakeCall_postProcess(
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper,
LONG lRes,
PDWORD_PTR callStateMsgParams
)
{
LONG lSuc;
HDRVLINE hdLine;
PDRVLINE pLine;
HDRVCALL hdCall;
PDRVCALL pCall;
TspLog(DL_TRACE, "lineMakeCall_post: lRes(%x)", lRes);
hdCall = (HDRVCALL)(pAsyncReqWrapper->dwRequestSpecific);
lSuc = GetLineHandleFromCallHandle(hdCall, &hdLine);
if (lSuc != TAPI_SUCCESS)
{
return lSuc;
}
lSuc = GetLineObjWithReadLock(hdLine, &pLine);
if (lSuc != TAPI_SUCCESS)
{
return lSuc;
}
lSuc = GetCallObjWithWriteLock(hdCall, &pCall);
if (lSuc != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lSuc;
}
if (TAPI_SUCCESS == lRes)
{
PNDIS_TAPI_MAKE_CALL pNdisTapiMakeCall = (PNDIS_TAPI_MAKE_CALL)
pAsyncReqWrapper->NdisTapiRequest.Data;
// check to see if a call state msg was received before we had
// the chance to process the completion notification, & if so
// fill in the msg params
if (pCall->dwPendingCallState)
{
callStateMsgParams[0] = (DWORD_PTR)pLine->htLine;
callStateMsgParams[1] = (DWORD_PTR)pCall->htCall;
callStateMsgParams[2] = pCall->dwPendingCallState;
callStateMsgParams[3] = pCall->dwPendingCallStateMode;
callStateMsgParams[4] = pCall->dwPendingMediaMode;
}
pCall->hd_Call = pNdisTapiMakeCall->hdCall;
pCall->bIncomplete = FALSE;
ReleaseObjWriteLock((HANDLE)hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
}
else
{
pCall->dwKey = INVALID_KEY;
ReleaseObjWriteLock((HANDLE)hdCall);
ReleaseObjReadLock((HANDLE)hdLine);
CloseObjHandle((HANDLE)hdCall);
}
return lRes;
}
LONG
TSPIAPI
TSPI_lineMakeCall(
DRV_REQUESTID dwRequestID,
HDRVLINE hdLine,
HTAPICALL htCall,
LPHDRVCALL lphdCall,
LPCWSTR lpszDestAddress,
DWORD dwCountryCode,
LPLINECALLPARAMS const lpCallParams
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PDRVCALL pCall;
HDRVCALL hdCall;
DWORD dwDALength, dwCPLength, dwOrgDALength;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_MAKE_CALL pNdisTapiMakeCall;
UINT nCodePage;
TspLog(DL_TRACE, "lineMakeCall(%d): reqID(%x), line(%p)",
++dwSum, dwRequestID, hdLine);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
// alloc & init a DRVCALL
if (!(pCall = AllocCallObj(sizeof(DRVCALL))))
{
TspLog(DL_ERROR, "lineMakeCall: failed to create call obj");
ReleaseObjReadLock((HANDLE)hdLine);
return LINEERR_NOMEM;
}
pCall->dwKey = OUTBOUND_CALL_KEY;
pCall->dwDeviceID = pLine->dwDeviceID;
pCall->htCall = htCall;
pCall->hdLine = hdLine;
pCall->bIncomplete = TRUE;
// set nCodePage depending on the medium type
nCodePage = (pLine->MediaType == NdisWanMediumPppoe) ? CP_UTF8 : CP_ACP;
// init the request
dwOrgDALength = (lpszDestAddress ? (lstrlenW (lpszDestAddress) + 1) : 0);
dwDALength = (lpszDestAddress ?
GetDestAddressLength(lpszDestAddress, dwOrgDALength, &nCodePage) : 0);
dwCPLength = (lpCallParams ?
(lpCallParams->dwTotalSize - sizeof(LINE_CALL_PARAMS)) : 0);
if ((lRes = PrepareAsyncRequest(
OID_TAPI_MAKE_CALL, // opcode
pLine->dwDeviceID, // device id
dwRequestID, // request id
sizeof(NDIS_TAPI_MAKE_CALL) +
dwDALength + dwCPLength, // size
&pAsyncReqWrapper // ptr to ptr to request buffer
)) != TAPI_SUCCESS)
{
FreeCallObj(pCall);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiMakeCall = (PNDIS_TAPI_MAKE_CALL)
pAsyncReqWrapper->NdisTapiRequest.Data;
// make sure releasing read lock before calling OpenObjHandle()
// to avoid deadlock on acquiring write lock for the global mapper
ReleaseObjReadLock((HANDLE)hdLine);
lRes = OpenObjHandle(pCall, FreeCallObj, (HANDLE *)&hdCall);
if (lRes != TAPI_SUCCESS)
{
TspLog(DL_ERROR,
"lineMakeCall: failed to map obj(%p) to handle",
pCall);
FreeRequest(pAsyncReqWrapper);
FreeCallObj(pCall);
return lRes;
}
// reacquire the read lock
lRes = AcquireObjReadLock((HANDLE)hdLine);
if (lRes != TAPI_SUCCESS)
{
TspLog(DL_ERROR,
"lineMakeCall: failed to reacquire read lock for obj(%p)",
hdLine);
FreeRequest(pAsyncReqWrapper);
CloseObjHandle((HANDLE)hdCall);
return lRes;
}
// save the TSP handle
pCall->hdCall = hdCall;
pNdisTapiMakeCall->hdLine = pLine->hd_Line;
pNdisTapiMakeCall->htCall = (HTAPI_CALL)hdCall;
pNdisTapiMakeCall->ulDestAddressSize = dwDALength;
if (lpszDestAddress)
{
pNdisTapiMakeCall->ulDestAddressOffset =
sizeof(NDIS_TAPI_MAKE_CALL) + dwCPLength;
// old miniports expect strings to be ascii
WideCharToMultiByte(
nCodePage,
0,
lpszDestAddress,
dwOrgDALength,
(LPSTR) (((LPBYTE) pNdisTapiMakeCall) +
pNdisTapiMakeCall->ulDestAddressOffset),
dwDALength,
NULL,
NULL
);
}
else
{
pNdisTapiMakeCall->ulDestAddressOffset = 0;
}
if (lpCallParams)
{
pNdisTapiMakeCall->bUseDefaultLineCallParams = FALSE;
CopyMemory(
&pNdisTapiMakeCall->LineCallParams,
lpCallParams,
lpCallParams->dwTotalSize
);
if (lpCallParams->dwOrigAddressSize != 0)
{
WideCharToMultiByte(
CP_ACP,
0,
(LPCWSTR) (((LPBYTE) lpCallParams) +
lpCallParams->dwOrigAddressOffset),
lpCallParams->dwOrigAddressSize / sizeof (WCHAR),
(LPSTR) (((LPBYTE) &pNdisTapiMakeCall->LineCallParams) +
lpCallParams->dwOrigAddressOffset),
lpCallParams->dwOrigAddressSize,
NULL,
NULL
);
pNdisTapiMakeCall->LineCallParams.ulOrigAddressSize /= 2;
}
}
else
{
pNdisTapiMakeCall->bUseDefaultLineCallParams = TRUE;
}
pAsyncReqWrapper->dwRequestSpecific = (DWORD_PTR)hdCall;
pAsyncReqWrapper->pfnPostProcess = TSPI_lineMakeCall_postProcess;
*lphdCall = hdCall;
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pAsyncReqWrapper);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineNegotiateExtVersion(
DWORD dwDeviceID,
DWORD dwTSPIVersion,
DWORD dwLowVersion,
DWORD dwHighVersion,
LPDWORD lpdwExtVersion
)
{
static DWORD dwSum = 0;
LONG lRes;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_NEGOTIATE_EXT_VERSION pNdisTapiNegotiateExtVersion;
TspLog(DL_TRACE,
"lineNegotiateExtVersion(%d): deviceID(%x), TSPIV(%x), "\
"LowV(%x), HighV(%x)",
++dwSum, dwDeviceID, dwTSPIVersion, dwLowVersion, dwHighVersion);
if ((lRes = PrepareSyncRequest(
OID_TAPI_NEGOTIATE_EXT_VERSION, // opcode
dwDeviceID, // device id
sizeof(NDIS_TAPI_NEGOTIATE_EXT_VERSION), // size of req data
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
return lRes;
}
pNdisTapiNegotiateExtVersion =
(PNDIS_TAPI_NEGOTIATE_EXT_VERSION)pNdisTapiRequest->Data;
pNdisTapiNegotiateExtVersion->ulDeviceID = dwDeviceID;
pNdisTapiNegotiateExtVersion->ulLowVersion = dwLowVersion;
pNdisTapiNegotiateExtVersion->ulHighVersion = dwHighVersion;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
*lpdwExtVersion = pNdisTapiNegotiateExtVersion->ulExtVersion;
// save version for future verification
lRes = SetNegotiatedExtVersion(dwDeviceID, *lpdwExtVersion);
}
else
{
TspLog(DL_WARNING, "lineNegotiateExtVersion: syncRequest returned(%x)",
lRes);
}
FreeRequest(pNdisTapiRequest);
return lRes;
}
LONG
TSPIAPI
TSPI_lineNegotiateTSPIVersion(
DWORD dwDeviceID,
DWORD dwLowVersion,
DWORD dwHighVersion,
LPDWORD lpdwTSPIVersion
)
{
static DWORD dwSum = 0;
LONG lRes;
TspLog(DL_TRACE, "lineNegotiateTSPIVersion(%d): deviceID(%x)",
++dwSum, dwDeviceID);
*lpdwTSPIVersion = 0x00010003; // until the ndistapi spec widened
// save version for future verification
lRes = SetNegotiatedTSPIVersion(dwDeviceID, 0x00010003);
if (TAPI_SUCCESS == lRes)
{
TspLog(DL_INFO, "lineNegotiateTSPIVersion: TSPIVersion(%x)",
*lpdwTSPIVersion);
}
return lRes;
}
LONG
TSPIAPI
TSPI_lineOpen(
DWORD dwDeviceID,
HTAPILINE htLine,
LPHDRVLINE lphdLine,
DWORD dwTSPIVersion,
LINEEVENT lpfnEventProc
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
HDRVLINE hdLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_OPEN pNdisTapiOpen;
GUID Guid;
NDIS_WAN_MEDIUM_SUBTYPE MediaType;
PNDISTAPI_OPENDATA OpenData;
TspLog(DL_TRACE, "lineOpen(%d): deviceID(%x), htLine(%p)",
++dwSum, dwDeviceID, htLine);
// alloc & init a DRVLINE
if (!(pLine = AllocLineObj(sizeof(DRVLINE))))
{
TspLog(DL_ERROR, "lineOpen: failed to create line obj");
return LINEERR_NOMEM;
}
pLine->dwKey = LINE_KEY;
pLine->dwDeviceID = dwDeviceID;
pLine->htLine = htLine;
if ((lRes = PrepareSyncRequest(
OID_TAPI_OPEN, // opcode
dwDeviceID, // device id
sizeof(NDIS_TAPI_OPEN) +
sizeof(NDISTAPI_OPENDATA), // size
&pNdisTapiRequest // ptr to ptr to request buffer
)) != TAPI_SUCCESS)
{
FreeLineObj(pLine);
return lRes;
}
pNdisTapiOpen = (PNDIS_TAPI_OPEN)pNdisTapiRequest->Data;
pNdisTapiOpen->ulDeviceID = dwDeviceID;
lRes = OpenObjHandle(pLine, FreeLineObj, (HANDLE *)&hdLine);
if (lRes != TAPI_SUCCESS)
{
TspLog(DL_ERROR, "lineOpen: failed to map obj(%p) to handle", pLine);
FreeLineObj(pLine);
FreeRequest(pNdisTapiRequest);
return lRes;
}
pNdisTapiOpen->htLine = (HTAPI_LINE)hdLine;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_QUERY_INFO, pNdisTapiRequest);
if (lRes != TAPI_SUCCESS)
{
CloseObjHandle((HANDLE)hdLine);
FreeRequest(pNdisTapiRequest);
return lRes;
}
OpenData = (PNDISTAPI_OPENDATA)
((PUCHAR)pNdisTapiOpen + sizeof(NDIS_TAPI_OPEN));
MoveMemory(&pLine->Guid,&OpenData->Guid, sizeof(pLine->Guid));
pLine->MediaType = OpenData->MediaType;
TspLog(DL_INFO, "lineOpen: obj(%p)", hdLine);
TspLog(
DL_INFO,
"Guid: %4.4x-%4.4x-%2.2x%2.2x-%1.1x%1.1x%1.1x%1.1x%1.1x%1.1x%1.1x",
pLine->Guid.Data1, pLine->Guid.Data2,
pLine->Guid.Data3, pLine->Guid.Data4[0],
pLine->Guid.Data4[1], pLine->Guid.Data4[2],
pLine->Guid.Data4[3], pLine->Guid.Data4[4],
pLine->Guid.Data4[5], pLine->Guid.Data4[6],
pLine->Guid.Data4[7]
);
TspLog(DL_INFO, "MediaType(%ld)", pLine->MediaType);
pLine->hd_Line = pNdisTapiOpen->hdLine;
*lphdLine = hdLine;
lRes = CommitNegotiatedTSPIVersion(dwDeviceID);
FreeRequest(pNdisTapiRequest);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSecureCall(
DRV_REQUESTID dwRequestID,
HDRVCALL hdCall
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_SECURE_CALL pNdisTapiSecureCall;
TspLog(DL_TRACE, "lineSecureCall(%d): reqID(%x), call(%p)",
++dwSum, dwRequestID, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareAsyncRequest(
OID_TAPI_SECURE_CALL, // opcode
pCall->dwDeviceID, // device id
dwRequestID, // req id
sizeof(NDIS_TAPI_SECURE_CALL), // size
&pAsyncReqWrapper // ptr to ptr to request buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiSecureCall =
(PNDIS_TAPI_SECURE_CALL)pAsyncReqWrapper->NdisTapiRequest.Data;
pNdisTapiSecureCall->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pAsyncReqWrapper);
return lRes;
}
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pAsyncReqWrapper);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSelectExtVersion(
HDRVLINE hdLine,
DWORD dwExtVersion
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_SELECT_EXT_VERSION pNdisTapiSelectExtVersion;
TspLog(DL_TRACE, "lineSelectExtVersion(%d): line(%p), ExtV(%x)",
++dwSum, hdLine, dwExtVersion);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_SELECT_EXT_VERSION, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_SELECT_EXT_VERSION), // size
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiSelectExtVersion =
(PNDIS_TAPI_SELECT_EXT_VERSION)pNdisTapiRequest->Data;
pNdisTapiSelectExtVersion->hdLine = pLine->hd_Line;
pNdisTapiSelectExtVersion->ulExtVersion = dwExtVersion;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequest);
if (TAPI_SUCCESS == lRes)
{
lRes = SetSelectedExtVersion(pLine->dwDeviceID, dwExtVersion);
}
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSendUserUserInfo(
DRV_REQUESTID dwRequestID,
HDRVCALL hdCall,
LPCSTR lpsUserUserInfo,
DWORD dwSize
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_SEND_USER_USER_INFO pNdisTapiSendUserUserInfo;
TspLog(DL_TRACE, "lineSendUserUserInfo(%d): reqID(%x), call(%p)",
++dwSum, dwRequestID, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareAsyncRequest(
OID_TAPI_SEND_USER_USER_INFO, // opcode
pCall->dwDeviceID, // device id
dwRequestID, // request id
sizeof(NDIS_TAPI_SEND_USER_USER_INFO) + dwSize,
&pAsyncReqWrapper // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiSendUserUserInfo = (PNDIS_TAPI_SEND_USER_USER_INFO)
pAsyncReqWrapper->NdisTapiRequest.Data;
pNdisTapiSendUserUserInfo->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pAsyncReqWrapper);
return lRes;
}
if (pNdisTapiSendUserUserInfo->ulUserUserInfoSize = dwSize)
{
CopyMemory(
pNdisTapiSendUserUserInfo->UserUserInfo,
lpsUserUserInfo,
dwSize
);
}
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pAsyncReqWrapper);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSetAppSpecific(
HDRVCALL hdCall,
DWORD dwAppSpecific
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_SET_APP_SPECIFIC pNdisTapiSetAppSpecific;
TspLog(DL_TRACE, "lineSetAppSpecific(%d): call(%p)", ++dwSum, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_SET_APP_SPECIFIC, // opcode
pCall->dwDeviceID, // device id
sizeof(NDIS_TAPI_SET_APP_SPECIFIC), // size
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiSetAppSpecific =
(PNDIS_TAPI_SET_APP_SPECIFIC)pNdisTapiRequest->Data;
pNdisTapiSetAppSpecific->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
return lRes;
}
pNdisTapiSetAppSpecific->ulAppSpecific = dwAppSpecific;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequest);
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSetCallParams(
DRV_REQUESTID dwRequestID,
HDRVCALL hdCall,
DWORD dwBearerMode,
DWORD dwMinRate,
DWORD dwMaxRate,
LPLINEDIALPARAMS const lpDialParams
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PASYNC_REQUEST_WRAPPER pAsyncReqWrapper;
PNDIS_TAPI_SET_CALL_PARAMS pNdisTapiSetCallParams;
TspLog(DL_TRACE, "lineSetCallParams(%d): reqID(%x), call(%p)",
++dwSum, dwRequestID, hdCall);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareAsyncRequest(
OID_TAPI_SET_CALL_PARAMS, // opcode
pCall->dwDeviceID, // device id
dwRequestID, // request id
sizeof(NDIS_TAPI_SET_CALL_PARAMS), // size
&pAsyncReqWrapper // ptr to ptr to request buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiSetCallParams =
(PNDIS_TAPI_SET_CALL_PARAMS)pAsyncReqWrapper->NdisTapiRequest.Data;
pNdisTapiSetCallParams->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pAsyncReqWrapper);
return lRes;
}
pNdisTapiSetCallParams->ulBearerMode = dwBearerMode;
pNdisTapiSetCallParams->ulMinRate = dwMinRate;
pNdisTapiSetCallParams->ulMaxRate = dwMaxRate;
if (lpDialParams)
{
pNdisTapiSetCallParams->bSetLineDialParams = TRUE;
CopyMemory(
&pNdisTapiSetCallParams->LineDialParams,
lpDialParams,
sizeof(LINE_DIAL_PARAMS)
);
}
else
{
pNdisTapiSetCallParams->bSetLineDialParams = FALSE;
}
lRes = AsyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pAsyncReqWrapper);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSetDefaultMediaDetection(
HDRVLINE hdLine,
DWORD dwMediaModes
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION pNdisTapiSetDefaultMediaDetection;
TspLog(DL_TRACE, "lineSetDefaultMediaDetection(%d): line(%p), mode(%x)",
++dwSum, hdLine, dwMediaModes);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_SET_DEFAULT_MEDIA_DETECTION, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION), // size
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiSetDefaultMediaDetection =
(PNDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION) pNdisTapiRequest->Data;
pNdisTapiSetDefaultMediaDetection->hdLine = pLine->hd_Line;
pNdisTapiSetDefaultMediaDetection->ulMediaModes = dwMediaModes;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequest);
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSetDevConfig(
DWORD dwDeviceID,
LPVOID const lpDeviceConfig,
DWORD dwSize,
LPCWSTR lpszDeviceClass
)
{
static DWORD dwSum = 0;
LONG lRes;
DWORD dwLength = lstrlenW(lpszDeviceClass) + 1;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_SET_DEV_CONFIG pNdisTapiSetDevConfig;
TspLog(DL_TRACE, "lineSetDevConfig(%d): deviceID(%x)", ++dwSum, dwDeviceID);
if ((lRes = PrepareSyncRequest(
OID_TAPI_SET_DEV_CONFIG, // opcode
dwDeviceID, // device id
sizeof(NDIS_TAPI_SET_DEV_CONFIG) + dwLength + dwSize,
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
return lRes;
}
pNdisTapiSetDevConfig = (PNDIS_TAPI_SET_DEV_CONFIG)pNdisTapiRequest->Data;
pNdisTapiSetDevConfig->ulDeviceID = dwDeviceID;
pNdisTapiSetDevConfig->ulDeviceClassSize = dwLength;
pNdisTapiSetDevConfig->ulDeviceClassOffset =
sizeof(NDIS_TAPI_SET_DEV_CONFIG) + dwSize - 1;
pNdisTapiSetDevConfig->ulDeviceConfigSize = dwSize;
CopyMemory(
pNdisTapiSetDevConfig->DeviceConfig,
lpDeviceConfig,
dwSize
);
// NOTE: old miniports expect strings to be ascii
WideCharToMultiByte(CP_ACP, 0, lpszDeviceClass, -1,
(LPSTR) (((LPBYTE) pNdisTapiSetDevConfig) +
pNdisTapiSetDevConfig->ulDeviceClassOffset),
dwLength, NULL, NULL);
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequest);
FreeRequest(pNdisTapiRequest);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSetMediaMode(
HDRVCALL hdCall,
DWORD dwMediaMode
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVCALL pCall;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_SET_MEDIA_MODE pNdisTapiSetMediaMode;
TspLog(DL_TRACE, "lineSetMediaMode(%d): call(%p), mode(%x)",
++dwSum, hdCall, dwMediaMode);
lRes = GetCallObjWithReadLock(hdCall, &pCall);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_SET_MEDIA_MODE, // opcode
pCall->dwDeviceID, // device id
sizeof(NDIS_TAPI_SET_MEDIA_MODE), // size
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
pNdisTapiSetMediaMode = (PNDIS_TAPI_SET_MEDIA_MODE)pNdisTapiRequest->Data;
pNdisTapiSetMediaMode->hdCall = GetNdisTapiHandle(pCall, &lRes);
if(lRes != TAPI_SUCCESS)
{
FreeRequest(pNdisTapiRequest);
return lRes;
}
pNdisTapiSetMediaMode->ulMediaMode = dwMediaMode;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequest);
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdCall);
return lRes;
}
LONG
TSPIAPI
TSPI_lineSetStatusMessages(
HDRVLINE hdLine,
DWORD dwLineStates,
DWORD dwAddressStates
)
{
static DWORD dwSum = 0;
LONG lRes;
PDRVLINE pLine;
PNDISTAPI_REQUEST pNdisTapiRequest;
PNDIS_TAPI_SET_STATUS_MESSAGES pNdisTapiSetStatusMessages;
TspLog(DL_TRACE, "lineSetStatusMessages(%d): line(%p)", ++dwSum, hdLine);
lRes = GetLineObjWithReadLock(hdLine, &pLine);
if (lRes != TAPI_SUCCESS)
{
return lRes;
}
if ((lRes = PrepareSyncRequest(
OID_TAPI_SET_STATUS_MESSAGES, // opcode
pLine->dwDeviceID, // device id
sizeof(NDIS_TAPI_SET_STATUS_MESSAGES), // size
&pNdisTapiRequest // ptr to ptr to req buf
)) != TAPI_SUCCESS)
{
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
pNdisTapiSetStatusMessages =
(PNDIS_TAPI_SET_STATUS_MESSAGES)pNdisTapiRequest->Data;
pNdisTapiSetStatusMessages->hdLine = pLine->hd_Line;
pNdisTapiSetStatusMessages->ulLineStates = dwLineStates;
pNdisTapiSetStatusMessages->ulAddressStates = dwAddressStates;
lRes = SyncDriverRequest(IOCTL_NDISTAPI_SET_INFO, pNdisTapiRequest);
FreeRequest(pNdisTapiRequest);
ReleaseObjReadLock((HANDLE)hdLine);
return lRes;
}
//
// TAPI_providerXxx funcs
//
LONG
TSPIAPI
TSPI_providerEnumDevices(
DWORD dwPermanentProviderID,
LPDWORD lpdwNumLines,
LPDWORD lpdwNumPhones,
HPROVIDER hProvider,
LINEEVENT lpfnLineCreateProc,
PHONEEVENT lpfnPhoneCreateProc
)
{
TspLog(DL_TRACE, "providerEnumDevices: permProvID(%x)",
dwPermanentProviderID);
//
// NOTE: We really enum devs in providerInit, see the
// special case note there
//
*lpdwNumLines = 0;
*lpdwNumPhones = 0;
gpfnLineEvent = lpfnLineCreateProc;
ghProvider = hProvider;
return 0;
}
LONG
TSPIAPI
TSPI_providerInit(
DWORD dwTSPIVersion,
DWORD dwPermanentProviderID,
DWORD dwLineDeviceIDBase,
DWORD dwPhoneDeviceIDBase,
DWORD_PTR dwNumLines,
DWORD_PTR dwNumPhones,
ASYNC_COMPLETION lpfnCompletionProc,
LPDWORD lpdwTSPIOptions
)
{
LONG lRes = LINEERR_OPERATIONFAILED;
char szDeviceName[] = "NDISTAPI";
char szTargetPath[] = "\\Device\\NdisTapi";
char szCompleteDeviceName[] = "\\\\.\\NDISTAPI";
DWORD cbReturned, dwThreadID;
DWORD adwConnectInfo[2];
TspLog(DL_TRACE, "providerInit: perfProvID(%x), lineDevIDBase(%x)",
dwPermanentProviderID, dwLineDeviceIDBase);
//
// inform tapisrv that we support multiple simultaneous requests
// (the WAN wrapper handles request serialization for miniports)
//
*lpdwTSPIOptions = 0;
//
// create symbolic link to the kernel-mode driver
//
DefineDosDevice(DDD_RAW_TARGET_PATH, szDeviceName, szTargetPath);
//
// open driver handles
//
if ((ghDriverSync = CreateFileA(
szCompleteDeviceName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, // no security attrs
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL // no template file
)) == INVALID_HANDLE_VALUE)
{
TspLog(DL_ERROR, "providerInit: CreateFile(%s, sync) failed(%ld)",
szCompleteDeviceName, GetLastError());
goto providerInit_error0;
}
if ((ghDriverAsync = CreateFileA(
szCompleteDeviceName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, // no security attrs
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL // no template file
)) == INVALID_HANDLE_VALUE)
{
TspLog(DL_ERROR, "providerInit: CreateFile(%s, async) failed(%ld)",
szCompleteDeviceName, GetLastError());
goto providerInit_error1;
}
//
// create io completion port
//
if ((ghCompletionPort = CreateIoCompletionPort(ghDriverAsync, NULL, 0, 0))
== INVALID_HANDLE_VALUE)
{
TspLog(DL_ERROR, "providerInit: CreateIoCompletionPort failed(%ld)",
GetLastError());
goto providerInit_error2;
}
//
// connect to driver- we send it a device ID base & it returns
// the number of devices it supports
//
{
adwConnectInfo[0] = dwLineDeviceIDBase;
adwConnectInfo[1] = 1;
if (!DeviceIoControl(
ghDriverSync,
IOCTL_NDISTAPI_CONNECT,
adwConnectInfo,
2 * sizeof(DWORD),
adwConnectInfo,
2 * sizeof(DWORD),
&cbReturned,
(LPOVERLAPPED)NULL
) ||
(cbReturned < sizeof(DWORD)))
{
TspLog(DL_ERROR, "providerInit: CONNECT failed(%ld)",
GetLastError());
goto providerInit_error3;
}
}
// init mapper, allocator and dev list
if (InitializeMapper() != TAPI_SUCCESS)
{
goto providerInit_error3_5;
}
InitAllocator();
//
// alloc the resources needed by the AsyncEventThread, and then
// create the thread
//
if ((gpAsyncEventsThreadInfo = (PASYNC_EVENTS_THREAD_INFO)
MALLOC(sizeof(ASYNC_EVENTS_THREAD_INFO))) == NULL)
{
TspLog(DL_ERROR, "providerInit: failed to alloc thread info");
goto providerInit_error4;
}
gpAsyncEventsThreadInfo->dwBufSize = EVENT_BUFFER_SIZE;
if ((gpAsyncEventsThreadInfo->pBuf = (PNDISTAPI_EVENT_DATA)
MALLOC(EVENT_BUFFER_SIZE)) == NULL)
{
TspLog(DL_ERROR, "providerInit: failed to alloc event buf");
goto providerInit_error5;
}
if ((gpAsyncEventsThreadInfo->hThread = CreateThread(
(LPSECURITY_ATTRIBUTES)NULL, // no security attrs
0, // default stack size
(LPTHREAD_START_ROUTINE) // func addr
AsyncEventsThread,
(LPVOID)NULL, // thread param
0, // create flags
&dwThreadID // thread id
)) == NULL)
{
TspLog(DL_ERROR, "providerInit: CreateThread failed(%ld)",
GetLastError());
goto providerInit_error7;
}
gdwRequestID = 1;
//
// !!! Special case for KMDDSP.TSP only !!!
//
// For KMDDSP.TSP only, TAPISRV.EXE will pass pointers in the
// dwNumLines/dwNumPhones variables rather than an actual
// number of lines/phones, thereby allowing the driver to tell
// TAPISRV.EXE how many devices are currently registered.
//
// This is really due to a design/interface problem in NDISTAPI.SYS.
// Since the current CONNECT IOCTLS expects both a device ID base &
// returns the num devs, we can't really do this in
// TSPI_providerEnumDevices as the device ID base is unknown
// at that point
//
*((LPDWORD)dwNumLines) = adwConnectInfo[0];
*((LPDWORD)dwNumPhones) = 0;
//
// if here success
//
gpfnCompletionProc = lpfnCompletionProc;
lRes = TAPI_SUCCESS;
goto providerInit_return;
//
// clean up resources if an error occured & then return
//
providerInit_error7:
FREE(gpAsyncEventsThreadInfo->pBuf);
providerInit_error5:
FREE(gpAsyncEventsThreadInfo);
providerInit_error4:
UninitAllocator();
UninitializeMapper();
providerInit_error3_5:
providerInit_error3:
CloseHandle(ghCompletionPort);
providerInit_error2:
CloseHandle(ghDriverAsync);
providerInit_error1:
CloseHandle(ghDriverSync);
providerInit_error0:
DefineDosDevice(DDD_REMOVE_DEFINITION, szDeviceName, NULL);
providerInit_return:
TspLog(DL_INFO, "providerInit: lRes(%x)", lRes);
return lRes;
}
LONG
TSPIAPI
TSPI_providerCreateLineDevice(
DWORD_PTR dwTempID,
DWORD dwDeviceID
)
{
DWORD cbReturned;
NDISTAPI_CREATE_INFO CreateInfo;
CreateInfo.TempID = dwTempID;
CreateInfo.DeviceID = dwDeviceID;
TspLog(DL_TRACE, "providerCreateLineDevice: tempID(%x), deviceID(%x)",
dwTempID, dwDeviceID);
if (!DeviceIoControl(
ghDriverSync,
IOCTL_NDISTAPI_CREATE,
&CreateInfo,
sizeof(CreateInfo),
&CreateInfo,
sizeof(CreateInfo),
&cbReturned,
(LPOVERLAPPED)NULL
))
{
TspLog(DL_ERROR, "providerCreateLineDevice: failed(%ld) to create",
GetLastError());
return LINEERR_OPERATIONFAILED;
}
return TAPI_SUCCESS;
}
LONG
TSPIAPI
TSPI_providerShutdown(
DWORD dwTSPIVersion,
DWORD dwPermanentProviderID
)
{
char deviceName[] = "NDISTAPI";
ASYNC_REQUEST_WRAPPER asyncRequestWrapper;
TspLog(DL_TRACE, "providerShutdown: perfProvID(%x)", dwPermanentProviderID);
// @@@ all we ought to have to do here is send a DISCONNECT IOCTL
//
// Close the driver & remove the symbolic link
//
CancelIo(ghDriverSync);
CancelIo(ghDriverAsync);
CloseHandle (ghDriverSync);
CloseHandle (ghDriverAsync);
CloseHandle (ghCompletionPort);
DefineDosDevice (DDD_REMOVE_DEFINITION, deviceName, NULL);
WaitForSingleObject(gpAsyncEventsThreadInfo->hThread, INFINITE);
CloseHandle(gpAsyncEventsThreadInfo->hThread);
FREE(gpAsyncEventsThreadInfo->pBuf);
FREE(gpAsyncEventsThreadInfo);
UninitAllocator();
UninitializeMapper();
return TAPI_SUCCESS;
}
BOOL
WINAPI
DllMain(
HANDLE hDLL,
DWORD dwReason,
LPVOID lpReserved
)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
{
#if DBG
{
HKEY hKey;
DWORD dwDataSize, dwDataType;
TCHAR szTelephonyKey[] =
"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony";
TCHAR szKmddspDebugLevel[] = "KmddspDebugLevel";
RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
szTelephonyKey,
0,
KEY_ALL_ACCESS,
&hKey
);
dwDataSize = sizeof(DWORD);
gdwDebugLevel = DL_WARNING;
RegQueryValueEx(
hKey,
szKmddspDebugLevel,
0,
&dwDataType,
(LPBYTE)&gdwDebugLevel,
&dwDataSize
);
RegCloseKey(hKey);
}
#endif
gdwTraceID = TraceRegisterA("KMDDSP");
ASSERT(gdwTraceID != INVALID_TRACEID);
TspLog(DL_TRACE, "DLL_PROCESS_ATTACH");
//
// Init global sync objects
//
InitializeCriticalSection(&gRequestIDCritSec);
InitLineDevList();
break;
}
case DLL_PROCESS_DETACH:
{
TspLog(DL_TRACE, "DLL_PROCESS_DETACH");
UninitLineDevList();
DeleteCriticalSection(&gRequestIDCritSec);
TraceDeregisterA(gdwTraceID);
break;
}
} // switch
return TRUE;
}
Reference in a new issue Copy permalink