ndistapi.c

WinCE5.0部分核心源码

	TapiOpen.ulDeviceID = pMac->dwDeviceID;
	TapiOpen.htLine = (HTAPI_LINE)pMac;

	pMac->bLineOpenInProgress = TRUE;
	pppUnLock(pMac->session);
	PppNdisDoSyncRequest (&Status,
							pMac->pAdapter,
							NdisRequestQueryInformation,
							OID_TAPI_OPEN,
							&TapiOpen,
							sizeof(TapiOpen));
	pppLock(pMac->session);
	pMac->bLineOpenInProgress = FALSE;
	SetEvent(pMac->hEventLineOpenComplete);
	
	if (Status == NDIS_STATUS_SUCCESS)
	{
		// Save the context value
		pMac->hLine = TapiOpen.hdLine;
		pMac->bLineClosed = FALSE;
	}

	return Status;
}

NDIS_STATUS
NdisTapiSetDefaultMediaDetection(
	IN	macCntxt_t *pMac,
	IN	DWORD		ulMediaModes)
//
//	Tell the miniport to listen for incoming connections
//
{
    NDIS_TAPI_SET_DEFAULT_MEDIA_DETECTION	SetMediaDetect;
	NDIS_STATUS								Status;

	SetMediaDetect.ulRequestID = 0;
	SetMediaDetect.hdLine = pMac->hLine;
	SetMediaDetect.ulMediaModes = ulMediaModes;

	pppUnLock(pMac->session);
	PppNdisDoSyncRequest (&Status,
							pMac->pAdapter,
							NdisRequestSetInformation,
							OID_TAPI_SET_DEFAULT_MEDIA_DETECTION,
							&SetMediaDetect,
							sizeof(SetMediaDetect));
	pppLock(pMac->session);
	
	return Status;
}

NDIS_STATUS
NdisTapiLineMakeCall(
	macCntxt_t *pMac,
	LPCTSTR szDialStr)
//
//	Request the miniport to place a call on the specified line to the specified
//	destination address.
//
{
	PNDIS_TAPI_MAKE_CALL	pTapiMakeCall;
	NDIS_STATUS				Status = NDIS_STATUS_RESOURCES;
	DWORD					dwNeededSize;
	LPBYTE					lpbDevConfig;
	DWORD  					dwDevConfigSize;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("ASYNCMAC: +NdisTapiLineMakeCall: dialStr=%s\n"), szDialStr));

    lpbDevConfig = ((pppSession_t *)(pMac->session))->lpbDevConfig;
    dwDevConfigSize = ((pppSession_t *)(pMac->session))->dwDevConfigSize;

	dwNeededSize = sizeof(NDIS_TAPI_MAKE_CALL)+(_tcslen(szDialStr)+1)*sizeof(TCHAR);
    if (lpbDevConfig) {
        dwNeededSize += dwDevConfigSize;
    }

	pTapiMakeCall = LocalAlloc (LPTR, dwNeededSize);

	if (pTapiMakeCall)
	{
		pTapiMakeCall->ulRequestID = 0;
		pTapiMakeCall->hdLine = pMac->hLine;
		pTapiMakeCall->htCall = (HTAPI_CALL)pMac;	// Do I need a call structure?
		pTapiMakeCall->bUseDefaultLineCallParams = TRUE;
		pTapiMakeCall->ulDestAddressSize = (_tcslen(szDialStr)+1)*sizeof(TCHAR);
        
        if (lpbDevConfig) {
            //
            // Pass the RASENTRY associated DEVCONFIG in LINECALLPARAMS.
            //
            pTapiMakeCall->bUseDefaultLineCallParams = FALSE;

            pTapiMakeCall->LineCallParams.ulTotalSize = sizeof(LINE_CALL_PARAMS) + dwDevConfigSize;
            pTapiMakeCall->LineCallParams.ulBearerMode = LINEBEARERMODE_DATA;
            pTapiMakeCall->LineCallParams.ulMinRate = 0;   // Any rate
            pTapiMakeCall->LineCallParams.ulMaxRate = 0;   // This should mean any max rate
            pTapiMakeCall->LineCallParams.ulMediaMode = LINEMEDIAMODE_DATAMODEM;
            pTapiMakeCall->LineCallParams.ulCallParamFlags = LINECALLPARAMFLAGS_IDLE;
            pTapiMakeCall->LineCallParams.ulAddressMode = LINEADDRESSMODE_ADDRESSID;
            pTapiMakeCall->LineCallParams.ulAddressID = 0;  // there's only one address
            pTapiMakeCall->LineCallParams.ulDeviceConfigSize = dwDevConfigSize;

            //
            // Making the assumption that ulDeviceConfigOffset is the offset from the 
            // beginning of LINE_CALL_PARAMS even though LINE_CALL_PARAMS is embedded
            // in an NDIS_TAPI_MAKE_CALL structure.
            //
            pTapiMakeCall->LineCallParams.ulDeviceConfigOffset = sizeof(LINE_CALL_PARAMS);
            memcpy((PBYTE)&pTapiMakeCall->LineCallParams + pTapiMakeCall->LineCallParams.ulDeviceConfigOffset,
                   lpbDevConfig,
                   dwDevConfigSize);

            //
            // Place the phone number at the very end of the NDIS_TAPI_MAKE_CALL allocation
            //
            pTapiMakeCall->ulDestAddressOffset = sizeof(NDIS_TAPI_MAKE_CALL) + dwDevConfigSize;
        } else {
            pTapiMakeCall->bUseDefaultLineCallParams = TRUE;
            pTapiMakeCall->ulDestAddressOffset = sizeof(NDIS_TAPI_MAKE_CALL);
        }
        memcpy((PBYTE)pTapiMakeCall + pTapiMakeCall->ulDestAddressOffset, szDialStr, pTapiMakeCall->ulDestAddressSize);

		pppUnLock(pMac->session);
		PppNdisDoSyncRequest (&Status,
								pMac->pAdapter,
								NdisRequestQueryInformation,
								OID_TAPI_MAKE_CALL,
								pTapiMakeCall,
								dwNeededSize);
		pppLock(pMac->session);

		DEBUGMSG (ZONE_ERROR && Status != NDIS_STATUS_SUCCESS,
				  (TEXT("!NdisTapiLineMakeCall: NdisRequest returned 0x%X\r\n"),
				   Status));

		if (Status == NDIS_STATUS_SUCCESS)
		{
			pMac->hCall = pTapiMakeCall->hdCall;
			pMac->bCallClosed = FALSE;
		}
	
		LocalFree (pTapiMakeCall);
	}

	DEBUGMSG(ZONE_FUNCTION, (TEXT("ASYNCMAC: -NdisTapiLineMakeCall: Status=%x\n"), Status));
	
	return Status;
}

NDIS_STATUS
NdisTapiGetCallInfo(
	IN	macCntxt_t				 *pMac,
	OUT PNDIS_TAPI_GET_CALL_INFO  pGetCallInfo)
//
//	Request the miniport to place a call on the specified line to the specified
//	destination address.
//
{
	NDIS_STATUS				Status = NDIS_STATUS_RESOURCES;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("ASYNCMAC: +NdisTapiGetCallInfo:\n")));

	pGetCallInfo->ulRequestID = 0;
	pGetCallInfo->hdCall = pMac->hCall;

	PppNdisDoSyncRequest (&Status,
							pMac->pAdapter,
							NdisRequestQueryInformation,
							OID_TAPI_GET_CALL_INFO,
							pGetCallInfo,
							sizeof(*pGetCallInfo));

	DEBUGMSG (ZONE_ERROR && Status != NDIS_STATUS_SUCCESS,
				  (TEXT("!NdisTapiGetCallInfo: NdisRequest returned 0x%X\r\n"),
				   Status));

	DEBUGMSG(ZONE_FUNCTION, (TEXT("ASYNCMAC: -NdisTapiGetCallInfo: Status=%x\n"), Status));
	
	return Status;

}

PNDIS_TAPI_GET_ID
createGetDeviceIDRequest(
	IN	macCntxt_t	*pMac,
	IN	ULONG		ulSelect,
	IN	PTSTR		tszDeviceClass,
	IN	DWORD		cbDeviceIDString,
	OUT	PDWORD		pdwRequestSize)
{

	PNDIS_TAPI_GET_ID	pTapiGetId;
	DWORD				cbDeviceClass;

	//
	//	The format of the request issued looks like:
	//
	//	ULONG		ulRequestID
	//	HDRV_LINE	hdLine
	//	ULONG		ulAddressID
	//	HDRV_CALL	hdCall
	//	ULONG		ulSelect
	//	ULONG		ulDeviceClassSize
	//	ULONG		ulDeviceClassOffset
	//	VAR_STRING	DeviceID
	//	[cbDeviceIdString bytes for DeviceID string]
	//	TCHAR		device class [ulDeviceClassSize bytes, null terminated]

	cbDeviceClass = (_tcslen(tszDeviceClass) + 1) * sizeof(TCHAR);

	*pdwRequestSize = sizeof(NDIS_TAPI_GET_ID) + cbDeviceIDString + cbDeviceClass;

	pTapiGetId = pppAllocateMemory(*pdwRequestSize);

	if (pTapiGetId)
	{
		pTapiGetId->ulRequestID = 0;
		pTapiGetId->hdLine = pMac->hLine;
		pTapiGetId->ulAddressID = (ULONG)pMac;
		pTapiGetId->hdCall = pMac->hCall;
		pTapiGetId->ulSelect = ulSelect;
		pTapiGetId->ulDeviceClassSize = cbDeviceClass;
		pTapiGetId->ulDeviceClassOffset = sizeof(NDIS_TAPI_GET_ID) + cbDeviceIDString;
		pTapiGetId->DeviceID.ulTotalSize = sizeof(VAR_STRING) + cbDeviceIDString;
		memcpy((PBYTE)pTapiGetId + pTapiGetId->ulDeviceClassOffset, (PBYTE)tszDeviceClass, cbDeviceClass);
	}

	return pTapiGetId;
}

#define TAPI_DEVICECLASS_NAME       "tapi/line"

void
NdisTapiLineGetIdCompleteCallback(
	NDIS_REQUEST_BETTER	*pRequest,
	PVOID				 FuncArg,
	NDIS_STATUS			 Status)
//
//	This function is called when the miniport driver completes
//	an OID_TAPI_GET_ID request.
//
{
	DEBUGMSG(ZONE_FUNCTION, (TEXT("PPP: +NdisTapiLineGetIdCompleteCallback Status=%x\n"), Status));

	if (Status == NDIS_STATUS_SUCCESS) 
	{
		// copy the returned device id, currently have no use for it

		
	}

	pppFreeMemory(pRequest->Request.DATA.SET_INFORMATION.InformationBuffer, pRequest->Request.DATA.SET_INFORMATION.InformationBufferLength);

	DEBUGMSG(ZONE_FUNCTION, (TEXT("PPP: -NdisTapiLineGetIdCompleteCallback\n")));
}

NDIS_STATUS
NdisTapiGetDeviceIdAsync(
	IN	macCntxt_t	*pMac,
	IN	ULONG		 ulSelect,
	IN	PTSTR		 tszDeviceClass)
{
	PNDIS_TAPI_GET_ID	pTapiGetId;
	DWORD				dwRequestSize;
	NDIS_STATUS			Status = NDIS_STATUS_RESOURCES;

	pTapiGetId = createGetDeviceIDRequest(pMac, ulSelect, tszDeviceClass, 0, &dwRequestSize);

	if (pTapiGetId)
	{
		pppUnLock(pMac->session);
		PppNdisIssueRequest(&Status, 
							pMac->pAdapter,
							NdisRequestQueryInformation,
							OID_TAPI_GET_ID,
							pTapiGetId,
							dwRequestSize,
							pMac,
							NdisTapiLineGetIdCompleteCallback,
							NULL,
							NULL);
		pppLock(pMac->session);
	}

	return Status;
}

NDIS_STATUS
NdisTapiGetDeviceId(
	IN	macCntxt_t	*pMac,
	IN	ULONG		 ulSelect,
	IN	PTSTR		 tszDeviceClass,
	OUT	PVAR_STRING	*pDeviceID OPTIONAL)
//
//	Do a synchronous request to retrieve the device ID.
//
{
	PNDIS_TAPI_GET_ID	pTapiGetId;
	NDIS_STATUS			Status;
	DWORD				dwRequestSize;
	DWORD				cbDeviceIDString;
	BOOL				bDone = FALSE;

	DEBUGMSG (ZONE_FUNCTION, (TEXT("PPP: +NdisTapiGetDeviceId\n")));

	cbDeviceIDString = 0;
	
	//
	//	Because the requested information is variable sized, we
	//	need to iterate until we pass a buffer sufficiently large
	//	to accomodate it.
	//
	do
	{
		pTapiGetId = createGetDeviceIDRequest(pMac, ulSelect, tszDeviceClass, cbDeviceIDString, &dwRequestSize);

		if (pTapiGetId == NULL)
		{
			Status = NDIS_STATUS_RESOURCES;
			break;
		}

		pppUnLock(pMac->session);
		PppNdisDoSyncRequest(&Status,
								pMac->pAdapter,
								NdisRequestQueryInformation,
								OID_TAPI_GET_ID,
								pTapiGetId,
								dwRequestSize);
		pppLock(pMac->session);


		if (Status != NDIS_STATUS_SUCCESS)
		{
			bDone = TRUE;
		}
		else
		{
			if (pTapiGetId->DeviceID.ulNeededSize <= pTapiGetId->DeviceID.ulTotalSize)
			{
				bDone = TRUE;
				if (pDeviceID)
				{
					// Allocate and copy the deviceID

					*pDeviceID = pppAllocateMemory(pTapiGetId->DeviceID.ulTotalSize);
					if (*pDeviceID == NULL)
					{
						Status = NDIS_STATUS_RESOURCES;
					}
					else
					{
						memcpy(*pDeviceID, &pTapiGetId->DeviceID, pTapiGetId->DeviceID.ulTotalSize);
					}
				}
			}
			else // Need a bigger buffer
			{
				ASSERT(pTapiGetId->DeviceID.ulNeededSize > sizeof(VAR_STRING));
				cbDeviceIDString = pTapiGetId->DeviceID.ulNeededSize - sizeof(VAR_STRING);
			}
		}
		pppFreeMemory(pTapiGetId, dwRequestSize);
	} while (!bDone);

	DEBUGMSG (ZONE_FUNCTION, (TEXT("PPP: -NdisTapiGetDeviceId: Status=%x\n"), Status));

	return Status;
}

void
NdisTapiLineAnswerCompleteCallback(
	NDIS_REQUEST_BETTER	*pRequest,
	PVOID				 FuncArg,
	NDIS_STATUS			 Status)
//
//	This function is called when the miniport driver completes
//	an OID_TAPI_CLOSE request that returned NDIS_STATUS_PENDING.
//
{
	DEBUGMSG(ZONE_FUNCTION, (TEXT("PPP: +NdisTapiLineAnswerCompleteCallback Status=%x\n"), Status));

	// Free the memory allocated for the NDIS_TAPI_ANSWER.
	pppFreeMemory(pRequest->Request.DATA.SET_INFORMATION.InformationBuffer, pRequest->Request.DATA.SET_INFORMATION.InformationBufferLength);

	DEBUGMSG(ZONE_FUNCTION, (TEXT("PPP: -NdisTapiLineAnswerCompleteCallback\n")));
}

NDIS_STATUS
NdisTapiLineAnswer(
	PVOID		pvMac,
	PUCHAR		pUserUserInfo,
	ULONG		ulUserUserInfoSize)
//
//	Used to answer an incoming call that we have been offered via the
//	LINE_NEWCALL indication from the miniport.
//
{
	macCntxt_t				*pMac = pvMac;
	PNDIS_TAPI_ANSWER		pTapiAnswer;
	NDIS_STATUS				Status;
	DWORD					dwNeededSize;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("PPP: +NdisTapiLineAnswer\n")));

	Status = NDIS_STATUS_RESOURCES;
	dwNeededSize = sizeof(NDIS_TAPI_ANSWER) + ulUserUserInfoSize;
	pTapiAnswer = pppAllocateMemory(dwNeededSize);
	if (pTapiAnswer)