adptlst.c

WinCE5.0部分核心源码

			pRasDevInfoV3 = (LPRASDEVINFOW_V3)pRasDevInfo;

			_tcsncpy(pRasDevInfoV3->szDeviceType,szDeviceType, RAS_MaxDeviceType);
			pRasDevInfoV3->szDeviceType[RAS_MaxDeviceType] = TEXT('\0');

			_tcsncpy(pRasDevInfoV3->szDeviceName, szDeviceName, RAS_MaxDeviceName_V3);
			pRasDevInfoV3->szDeviceName[RAS_MaxDeviceName_V3] = TEXT('\0');
		}
		else
		{
			_tcsncpy(pRasDevInfo->szDeviceType,szDeviceType, RAS_MaxDeviceType);
			pRasDevInfo->szDeviceType[RAS_MaxDeviceType] = TEXT('\0');

			_tcsncpy(pRasDevInfo->szDeviceName, szDeviceName, RAS_MaxDeviceName);
			pRasDevInfo->szDeviceName[RAS_MaxDeviceName] = TEXT('\0');
		}
				
		DEBUGMSG (ZONE_MAC, (TEXT("WalkDevEnum: %d '%s' '%s'\r\n"),
					  pEnumDevInfo->cDevices,
					  pRasDevInfo->szDeviceName,
					  pRasDevInfo->szDeviceType));
					  
		pEnumDevInfo->cDevices++;
	}

	// Return FALSE to keep walking since we need to enumerate all devices
	return FALSE;
}


BOOL
WalkDevices (
	PNDISWAN_ADAPTER pAdapter,
	PVOID            pContext1,
	PVOID            pContext2)
//
//  Call a function for each device that the adapter has.
//
{
    DWORD	                i;
    PWALKDEVICESINFO        pWalkDevicesInfo = (PWALKDEVICESINFO)pContext1;
    PFN_DEVWALK		        pfnDevWalk = pWalkDevicesInfo->pfnDevWalk;
	PNDISTAPI_DEVICE_INFO   pDevInfo;
	BOOL                    bStopWalking = FALSE;

    for (i=0; i < pAdapter->dwNumDevices; i++)
	{
		pDevInfo = &pAdapter->pDeviceInfo[i];

		//
		//  Stop enumerating if we encounter an uninitialized device.
		//  That is, we may be in the process of gathering info on the device
		//  via an OID_TAPI_GET_DEV_CAPS request. Until that request completes,
		//  the device is not enumerable.
		//
		if (NULL == pDevInfo->pwszDeviceName
		||  NULL == pDevInfo->pwszDeviceType)
		{
			break;
		}

		//  If we only want a null modem device, ignore others
		//
        if (FALSE == pWalkDevicesInfo->bOnlyWalkNullModem
		||  TRUE  == pDevInfo->bIsNullModem)
		{
			DEBUGMSG (ZONE_MAC, (TEXT("WalkEnumDev: Adpt '%s' Dev %d Name=%s Type=%s\r\n"),
									pAdapter->szAdapterName, i, pDevInfo->pwszDeviceName, pDevInfo->pwszDeviceType));

			bStopWalking = pfnDevWalk(pAdapter, i, pContext2, pDevInfo->pwszDeviceName, pDevInfo->pwszDeviceType);
			if (bStopWalking)
				break;
        }
    }
    
    return bStopWalking;
}

DWORD
pppMac_EnumDevices (
	IN	OUT	LPRASDEVINFOW	pRasDevInfo, OPTIONAL
	IN		BOOL			bOnlyWalkNullModem,
	IN	OUT	LPDWORD			lpcb,
		OUT	LPDWORD			lpcDevices)
//
//  Return information on all the RAS devices.
//
{
	ENUMDEVICESINFO	EnumDevInfo;
	WALKDEVICESINFO WalkDevInfo;

	DEBUGMSG (ZONE_RAS | ZONE_FUNCTION,
			  (TEXT("+pppMAC_EnumDevices( 0x%08X, 0x%08X, 0x%08X )\r\n"), 
			   pRasDevInfo, lpcb, lpcDevices));

	//
	//	Validate input parameters
	//
	EnumDevInfo.dwRetVal = NO_ERROR;
	if (lpcb == NULL || lpcDevices == NULL)
		EnumDevInfo.dwRetVal = ERROR_INVALID_PARAMETER;
	else
	{
		//
		//	The application indicates which version of the RASDEVINFOW
		//	structure it is using by setting pRasDevInfo->dwSize.
		//
		//	If the app does not provide a pRasDevInfo structure from
		//	which to get the size, default to the larger structure.
		//	This will cause an old app to allocate more memory than
		//	required, but its subsequent call should work ok.
		//
		EnumDevInfo.dwSizeDevInfo = sizeof(RASDEVINFOW);
		if (pRasDevInfo)
		{
			if (*lpcb < sizeof(DWORD))
				EnumDevInfo.dwRetVal = ERROR_BUFFER_TOO_SMALL;
			else if (pRasDevInfo->dwSize < sizeof(RASDEVINFOW_V3))
				EnumDevInfo.dwRetVal = ERROR_BUFFER_TOO_SMALL;
			else if (pRasDevInfo->dwSize == sizeof(RASDEVINFOW_V3))
				EnumDevInfo.dwSizeDevInfo = sizeof(RASDEVINFOW_V3);
			else if (pRasDevInfo->dwSize < sizeof(RASDEVINFOW))
				EnumDevInfo.dwRetVal = ERROR_BUFFER_TOO_SMALL;
			else
				EnumDevInfo.dwSizeDevInfo = sizeof(RASDEVINFOW);
		}
	}

	if (EnumDevInfo.dwRetVal == NO_ERROR)
	{
		EnumDevInfo.pRasDevInfo = pRasDevInfo;
		EnumDevInfo.cbMax		= pRasDevInfo ? *lpcb : 0;
		EnumDevInfo.cb			= 0;
		EnumDevInfo.cDevices	= 0;
		EnumDevInfo.dwRetVal	= SUCCESS;

		WalkDevInfo.pfnDevWalk         = WalkDevEnum;
		WalkDevInfo.bOnlyWalkNullModem = bOnlyWalkNullModem;

		WalkAdapters(WalkDevices, &WalkDevInfo, &EnumDevInfo);

		DEBUGMSG(ZONE_MAC, (L"pppMAC_EnumDevices: cb=%d cDevices=%d\r\n", EnumDevInfo.cb, EnumDevInfo.cDevices));

		// Copy the data back.
		*lpcb = EnumDevInfo.cb;
		*lpcDevices = EnumDevInfo.cDevices;
	}
	DEBUGMSG (ZONE_RAS | ZONE_FUNCTION | (ZONE_ERROR && EnumDevInfo.dwRetVal),
			  (TEXT( "-pppMAC_EnumDevices: Return Value %d\r\n"), 
			   EnumDevInfo.dwRetVal));
	return EnumDevInfo.dwRetVal;
}


VOID
WalkAdapters(
	IN  PFN_ADPTWALK pfnAdapterWalk,
	IN  PVOID        pContext1,
	IN  PVOID        pContext2)
//
//  Iterate through the list of NDIS WAN miniport drivers registered with PPP,
//  calling pfnAdapterWalk on each one until either it returns TRUE or the
//  end of the list is reached.
//
{
	PNDISWAN_ADAPTER	pAdapter;
	BOOL                bStopWalking;
	
	// Walk each adapter, open it and call the pfnAdapterWalk function.
	EnterCriticalSection(&v_AdapterCS);
	for (pAdapter = v_AdapterList; NULL != pAdapter; pAdapter = pAdapter->pNext)
	{
		//
        // The v_AdapterCS MUST be released prior to calling pfnAdapterWalk,
		// otherwise pfnAdapterWalk may block on something and create a potential
		// deadlock scenario if some other thread needs v_AdapterCS.
		//
		// To prevent pAdapter from being deleted while we are using it,
		// we take a reference to it.
		//
		AdapterAddRefLocked(pAdapter);
		LeaveCriticalSection(&v_AdapterCS);

		// Call the specified function
		bStopWalking = pfnAdapterWalk (pAdapter, pContext1, pContext2);

		EnterCriticalSection(&v_AdapterCS);
		AdapterDelRefLocked(pAdapter);

		if (bStopWalking)
		{
			// pfnAdapterWalk requested loop termination
			break;
		}
	}
	LeaveCriticalSection(&v_AdapterCS);
}

typedef struct _tagFindAdapter
{
	LPCTSTR	szDeviceName;
	LPCTSTR	szDeviceType;
	PNDISWAN_ADAPTER	pAdapter;
	DWORD				dwDeviceID;
	DWORD	dwRetVal;
} FINDADAPTER, *PFINDADAPTER;

BOOL
WalkDevFindDevice(
	PNDISWAN_ADAPTER		pAdapter,
	DWORD					dwDevID,
	PVOID					pContext,
	LPCTSTR					szDeviceName,
	LPCTSTR					szDeviceType)
//
//  This function is called by WalkDevices to see if a device is the
//  one we are looking for.
//
//  Returns TRUE if this device matches, which terminates the walk.
//
{
	PFINDADAPTER	pFindAdapter = (PFINDADAPTER)pContext;
	BOOL            bStopWalking = FALSE;
	
	if (0 == _tcsncmp(pFindAdapter->szDeviceName, szDeviceName, RAS_MaxDeviceName) &&
		0 == _tcscmp(pFindAdapter->szDeviceType, szDeviceType))
	{
		pFindAdapter->pAdapter = pAdapter;
		pFindAdapter->dwDeviceID = dwDevID;
		pFindAdapter->dwRetVal = SUCCESS;
		AdapterAddRef (pAdapter);
		// Stop the search....
		bStopWalking = TRUE;
	}
	return bStopWalking;
}

BOOL
FindAdapter (
	IN		LPCTSTR				szDeviceName,
	IN		LPCTSTR				szDeviceType,
		OUT	PNDISWAN_ADAPTER	*ppAdapter,
		OUT	LPDWORD				pdwDevID)
//
//	Return value:
//		TRUE	if successful (adapter found)
//		FALSE	if the adapter is not found
//
//	NOTE: If successful, a reference is added to the adapter returned
//		  in *ppAdapter.  The caller must delete this reference when
//		  done using the returned pointer by calling AdapterDelRef.
//
{
	FINDADAPTER	FindAdaptInfo;
	WALKDEVICESINFO WalkDevInfo;

	// Setup the param struct
	FindAdaptInfo.szDeviceName = szDeviceName;
	FindAdaptInfo.szDeviceType = szDeviceType;
	FindAdaptInfo.pAdapter = NULL;
	FindAdaptInfo.dwDeviceID = 0;
	FindAdaptInfo.dwRetVal = ERROR_DEVICENAME_NOT_FOUND;
	
	WalkDevInfo.pfnDevWalk         = WalkDevFindDevice;
	WalkDevInfo.bOnlyWalkNullModem = FALSE;

	WalkAdapters(WalkDevices, &WalkDevInfo, &FindAdaptInfo);

	if (SUCCESS == FindAdaptInfo.dwRetVal)
	{
		*ppAdapter = FindAdaptInfo.pAdapter;
		*pdwDevID = FindAdaptInfo.dwDeviceID;
	}

	return FindAdaptInfo.dwRetVal;
}