ras.c

WinCE5.0部分核心源码

	DWORD	         RetVal = NO_ERROR;
	DWORD            NumRequested;
	PPP_CONTEXT     *pppCntxt_p = NULL;

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

	if (NULL == lpRasConn || NULL == lpcb || NULL == lpcConnections)
		return ERROR_INVALID_PARAMETER;

    // Validate size of structure

    if( sizeof( RASCONN ) != lpRasConn->dwSize )
    {
        // Passed in size is incorrect.  The dwSize must 
        // be equal to the sizeof the RASCONN structure.

        return ERROR_INVALID_SIZE;
    }

    // Compute number of connections requested from buffer size

    NumRequested = (*lpcb) / sizeof( RASCONN );
	
    // Initialize return parameters

    *lpcb = 0;                                  // size in bytes of return
    *lpcConnections = 0;                        // # written to buffer

    // Loop through the contexts

	EnterCriticalSection (&v_ListCS);

    for( pppCntxt_p = pppContextList; 
         pppCntxt_p; 
         pppCntxt_p = pppCntxt_p->Next )
    {
        DEBUGMSG( ZONE_RAS, ( TEXT( " Data\r\n" ) ) );

		//
		//	Do not count null sessions (is this possible?) or server sessions
		//
        if( pppCntxt_p->Session == NULL || pppCntxt_p->Session->bIsServer)
        {
            continue;
        }

		DEBUGMSG(ZONE_RAS, (TEXT("RAS: RasEnumConnections Found Entry Name: '%s'\n" ), lpRasConn->szEntryName ));

        // Copy this one into the provided buffer

        if( 0 == NumRequested )
		{
			// have run out of buffer space
			RetVal = ERROR_BUFFER_TOO_SMALL;
		}
		else
		{
			// Fill in request

			(*lpcConnections)++;                // # written to buffer

			// Fill in the request
			lpRasConn->dwSize   = sizeof( RASCONN );
			lpRasConn->hrasconn = (HRASCONN )pppCntxt_p->Session;
			_tcscpy(lpRasConn->szEntryName, pppCntxt_p->Session->rasDialParams.szEntryName );

			lpRasConn++;                        // Access next slot
			NumRequested--;
		}

        (*lpcb) += sizeof( RASCONN );       // we always update the required size so callers can tell how much to allocate
    }

	LeaveCriticalSection (&v_ListCS);

	DEBUGMSG(ZONE_RAS && RetVal == ERROR_BUFFER_TOO_SMALL, (TEXT("RAS: RasEnumConnections - Caller BUFFER_TOO_SMALL.\n")));

	DEBUGMSG( ZONE_RAS | ZONE_FUNCTION, (TEXT( "PPP: -RasEnumConnections() numConn=%u\n" ), *lpcConnections));
    
    
	return RetVal;
}

/*****************************************************************************
* 
*   @func   DWORD | RasGetConnectStatus | Get connection status
*
*   @rdesc  If the function succeeds the value is zero. Else an error
*           from raserror.h is returned.
*   @ecode  ERROR_INVALID_PARAMETER | Invalid hRasConn or pRasConnStatus
*           parameter.
*   
*   @parm   HRASCONN        | hRasConn   |
*               Handle of Ras Connection
*   @parm   LPRASCONNSTATE  | pRasConnStatus |
*               Pointer to struct to return inf.
*               
*
*/

DWORD APIENTRY
AfdRasGetConnectStatus( HRASCONN hrasconn, LPRASCONNSTATUS lprasconnstatus )
{
	pppSession_t    *s_p = (pppSession_t *)hrasconn;
	DWORD	rc = SUCCESS;

    DEBUGMSG( ZONE_RAS | ZONE_FUNCTION,
			  (TEXT( "PPP:+AfdRasGetConnectStatus (%08X, %08X)\r\n" ), 
			   hrasconn, lprasconnstatus ) );

	if (NULL == lprasconnstatus) {
		rc = ERROR_INVALID_PARAMETER;
	} else {

		if (PPPADDREF (s_p, REF_GETCONNECTSTATUS))
		{
			lprasconnstatus->rasconnstate = s_p->RasConnState;
			lprasconnstatus->dwError      = s_p->RasError;
			_tcscpy( lprasconnstatus->szDeviceType, s_p->rasEntry.szDeviceType );
			_tcscpy( lprasconnstatus->szDeviceName, s_p->rasEntry.szDeviceName );
			
			PPPDELREF (s_p, REF_GETCONNECTSTATUS);
		} else {
			rc = ERROR_INVALID_HANDLE;
		}
	}

    DEBUGMSG (ZONE_RAS | ZONE_FUNCTION,
			  (TEXT("PPP:-AfdRasGetConnectStatus: Returning %d\r\n"), 
			   rc));
    return (rc);
}


DWORD APIENTRY
AfdRasGetProjectionInfo(HRASCONN hrasconn, RASPROJECTION rasprojection,
                        LPVOID lpprojection, LPDWORD lpcb)
{
	pppSession_t    *s_p = (pppSession_t *)hrasconn;
	DWORD	rc = SUCCESS;
	RASPPPIP *r_p;
	ncpCntxt_t      *ncp_p;
	ipcpCntxt_t     *ipcp_p;
	DWORD LocalIP,
		  PeerIP;

    DEBUGMSG (ZONE_RAS | ZONE_FUNCTION,
			  (TEXT( "PPP:+AfdRasGetProjectionInfo (%08X, %08X)\r\n"), 
			   hrasconn, lpprojection));

    if (NULL == lpcb) {
		rc = ERROR_INVALID_PARAMETER;
    } 
	else
	{
		if (PPPADDREF (s_p, REF_GETPROJECTIONINFO)) 
		{
			switch (rasprojection) 
			{
				case RASP_PppIp:
					r_p = (RASPPPIP *)lpprojection;
					ncp_p  = (ncpCntxt_t  *)s_p->ncpCntxt;
					ipcp_p = (ipcpCntxt_t *)ncp_p->protocol[ NCP_IPCP ].context;
					LocalIP =  ipcp_p->local.ipAddress;
					PeerIP =   ipcp_p->peer.ipAddress;
										
					// Check state (CE never enters projected state)
					if (ipcp_p->pFsm->state < PFS_Opened)
					{
						rc = ERROR_PROJECTION_NOT_COMPLETE;
						break;
					}

					//
					//	Additional fields have been added to the RASPPIP
					//  structure in various releases.  Fill in all the
					//  fields for which the user has supplied space.
					//
					if (r_p->dwSize < offsetof(RASPPPIP, szServerIpAddress)) {
						rc = ERROR_BUFFER_TOO_SMALL;
						break;
					}

					//
					//	Space is available for the dwError and szIpAddress
					//
					r_p->dwError = s_p->RasError;
					wsprintf(r_p->szIpAddress,L"%u.%u.%u.%u",
						 (LocalIP>>24)&0xFF,(LocalIP>>16)&0xFF,
						(LocalIP>>8)&0xFF,LocalIP&0xFF);

					//
					//  Check for space for the serverIpAddress field
					//
					if (r_p->dwSize < offsetof(RASPPPIP, dwOptions))
						break;
	
					r_p->szServerIpAddress[0] = TEXT('\0');
					if (PeerIP)
					{
						wsprintf(r_p->szServerIpAddress,L"%u.%u.%u.%u",
								 (PeerIP>>24)&0xFF,(PeerIP>>16)&0xFF,
								 (PeerIP>>8)&0xFF,PeerIP&0xFF);
					}

					//
					//  Check for space for the dwOptions
					//
					if (r_p->dwSize < offsetof(RASPPPIP, dwServerOptions))
						break;

					r_p->dwOptions = ipcp_p->local.VJCompressionEnabled ? RASIPO_VJ : 0;


					//
					//  Check for space for the dwServerOptions
					//
					if (r_p->dwSize < sizeof(RASPPPIP))
						break;

					r_p->dwServerOptions = ipcp_p->peer.VJCompressionEnabled ? RASIPO_VJ : 0;

					break;

				case RASP_PppIpV6:
				{
					LPRASPPPIPV6 pIPV6Projection;
					PIPV6Context pIPV6Context;

					pIPV6Projection = (LPRASPPPIPV6)lpprojection;
					ncp_p  = (ncpCntxt_t  *)s_p->ncpCntxt;
					pIPV6Context = (PIPV6Context)(ncp_p->protocol[NCP_IPV6CP].context);

					if (pIPV6Projection->dwSize < sizeof(RASPPPIPV6))
					{
						rc = ERROR_BUFFER_TOO_SMALL;
						break;
					}

					if (ncp_p->protocol[NCP_IPV6CP].enabled == FALSE)
					{
						rc = ERROR_PROTOCOL_NOT_CONFIGURED;
						break;
					}

					if (pIPV6Context->pFsm->state < PFS_Opened)
					{
						rc = ERROR_PROJECTION_NOT_COMPLETE;
						break;
					}

					pIPV6Projection->dwError = NO_ERROR;
					memcpy(&pIPV6Projection->LocalInterfaceIdentifier[0], &pIPV6Context->LocalInterfaceIdentifier[0], IPV6_IFID_LENGTH);
					memcpy(&pIPV6Projection->PeerInterfaceIdentifier[0], &pIPV6Context->PeerInterfaceIdentifier[0], IPV6_IFID_LENGTH);
					memcpy(&pIPV6Projection->LocalCompressionProtocol[0], &pIPV6Context->LocalCompressionProtocol[0], 2);
					memcpy(&pIPV6Projection->PeerCompressionProtocol[0], &pIPV6Context->PeerCompressionProtocol[0], 2);

					break;
				}

				default:
					rc = ERROR_PROTOCOL_NOT_CONFIGURED;
					break;
			}

			PPPDELREF (s_p, REF_GETPROJECTIONINFO);
		} 
		else 
		{
			rc = ERROR_INVALID_HANDLE;
		}
	}

	DEBUGMSG (ZONE_RAS, (TEXT("PPP:-AfdRasGetProjectionInfo: Returning %d\r\n"), rc));
	return rc;
}


/*****************************************************************************
* 
*   @func   DWORD | pppGetRasStats | Get connection statistics
*
*   @rdesc  If the function succeeds the value is zero. Else an error
*           from raserror.h is returned.
*   @ecode  ERROR_INVALID_PARAMETER | Invalid hRasConn or pRasStat
*           parameter.
*   
*   @parm   HRASCONN        | hRasConn   |
*               Handle of Ras Connection
*   @parm   PRAS_STATS      | pRasStat |
*               Pointer to struct to return inf.
*               
*
*/

DWORD
pppGetRasStats(
	HRASCONN hRasConn,
	PRAS_STATS pRasStats)
{
	pppSession_t			*s_p = (pppSession_t *)hRasConn;
	NDIS_STATUS				Status;
	NDIS_WAN_GET_STATS_INFO	MacStats;

	DEBUGMSG (ZONE_RAS|ZONE_FUNCTION,
			  (TEXT("ppp:+pppGetRasStats (0x%08X, 0x%08X)\r\n"),
			   hRasConn, pRasStats));

	// Check size?
	if (pRasStats->dwSize != sizeof(RAS_STATS))
	{
		DEBUGMSG (ZONE_ERROR|ZONE_RAS, (TEXT("ppp:-pppGetRasStats: pRasStats->dwSize not correct size\r\n")));
		return ERROR_INVALID_PARAMETER;
	}

	if (PPPADDREF (s_p, REF_GETRASSTATS))
	{
		// Clear buffer
		CTEMemSet( (char *)pRasStats, 0, sizeof(RAS_STATS) );
		pRasStats->dwSize = sizeof(RAS_STATS);

		// Use MAC layer stats if available
		Status = pppMacGetWanStats(s_p->macCntxt, &MacStats);
		if (Status == NDIS_STATUS_SUCCESS)
		{
			// Use stats provided by miniport
			
			pRasStats->dwBytesXmited = MacStats.BytesSent;
			pRasStats->dwBytesRcved = MacStats.BytesRcvd;
			pRasStats->dwFramesXmited = MacStats.FramesSent;
			pRasStats->dwFramesRcved = MacStats.FramesRcvd;

			pRasStats->dwCrcErr = MacStats.CRCErrors;
			pRasStats->dwTimeoutErr = MacStats.TimeoutErrors;
			pRasStats->dwAlignmentErr = MacStats.AlignmentErrors;
			pRasStats->dwHardwareOverrunErr = MacStats.SerialOverrunErrors;
			pRasStats->dwFramingErr = MacStats.FramingErrors;
			pRasStats->dwBufferOverrunErr = MacStats.BufferOverrunErrors;
		}
		else // No MAC stats available
		{
			// Use PPP stats for frames and bytes.
			pRasStats->dwBytesXmited = s_p->Stats.BytesSent;
			pRasStats->dwBytesRcved = s_p->Stats.BytesRcvd;
			pRasStats->dwFramesXmited = s_p->Stats.FramesSent;
			pRasStats->dwFramesRcved = s_p->Stats.FramesRcvd;
		}

		//
		//  Compression Ratios specify a percentage that indicates the degree
		//  to which data received on this connection is compressed.
		//  The ratio is the size of the compressed data divided by the size
		//  of the same data in an uncompressed state. 
		//
		pRasStats->dwCompressionRatioIn = 100;
		if (s_p->Stats.BytesReceivedUncompressed)
		{
			pRasStats->dwCompressionRatioIn = (s_p->Stats.BytesReceivedCompressed * 100) /
											  s_p->Stats.BytesReceivedUncompressed;
		}
		pRasStats->dwCompressionRatioOut = 100;
		if (s_p->Stats.BytesTransmittedUncompressed)
		{
			pRasStats->dwCompressionRatioOut = (s_p->Stats.BytesTransmittedCompressed * 100) /
											  s_p->Stats.BytesTransmittedUncompressed;
		}
		pppMac_GetCallSpeed(s_p->macCntxt, &pRasStats->dwBps);
		pRasStats->dwConnectDuration = GetTickCount() - s_p->dwStartTickCount;

		PPPDELREF(s_p, REF_GETRASSTATS);
	}
	else
	{
		DEBUGMSG (ZONE_ERROR, (TEXT("ppp:pppGetRasStats: Invalid hRasConn passed in\r\n")));
		return ERROR_INVALID_HANDLE;
	}

	DEBUGMSG (ZONE_RAS|ZONE_FUNCTION, (TEXT("ppp:-pppGetRasStats : Success \r\n")));
	return (SUCCESS);
}	

DWORD
PPPDevConfigDialogEdit(
	IN		PTCHAR		szDeviceName,
	IN		PTCHAR		szDeviceType,
	IN		HWND		hWndOwner,
	IN		PBYTE		pDeviceConfigIn,
	IN		DWORD		dwDeviceConfigInSize,
	IN	OUT LPVARSTRING pDeviceConfigOut)
{
	DWORD	RetVal;

	PNDISWAN_ADAPTER		pAdapter;
	DWORD					dwDeviceID;

	RetVal = FindAdapter(szDeviceName, szDeviceType, &pAdapter, &dwDeviceID);
	if (RetVal != SUCCESS)
	{
		DEBUGMSG (ZONE_ERROR, (TEXT("ppp: PPPDevConfigDialogEdit: Can't find device '%s'\n"), szDeviceName));
	}
	else
	{
		RetVal = NdisTapiLineConfigDialogEdit(pAdapter, dwDeviceID, hWndOwner,
					NULL, pDeviceConfigIn, dwDeviceConfigInSize, pDeviceConfigOut);

		AdapterDelRef (pAdapter);
	}

	return RetVal;
}

DWORD
pppRasCntlGetDispPhone(
    PBYTE   pBufIn,
    DWORD   dwLenIn, 
    PBYTE   pBufOut, 
    DWORD   dwLenOut,
    PDWORD  pdwActualOut)
//
//  Handle RASCNTL_GETDISPPHONE
//
{
	RASENTRY RasEntry;
	DWORD	dwSize = sizeof(RasEntry);
	DWORD	dwDeviceID;
	PNDISWAN_ADAPTER	pAdapter;
	DWORD	dwFlag;
	LPTSTR	szDialStr;
	DWORD   RetVal;

	do
	{
		if ((0 == dwLenOut) || (NULL == pBufOut) || (NULL == pBufIn))
		{
			RetVal = ERROR_INVALID_PARAMETER;
			DEBUGMSG (ZONE_ERROR, (TEXT("PPP: ERROR - pppRasCntlGetDispPhone : Invalid Parameter\r\n")));
			break;
		}

		// First get the RasEntry Info