windows-server-2003/net/rras/dim/admindll/apistub.c

/*********************************************************************/
/**               Copyright(c) 1995 Microsoft Corporation.	        **/
/*********************************************************************/

//***
//
// Filename:	apistub.c
//
// Description: This module contains the DIM/DDM server API RPC
//		        client stubs.
//
// History:     June 11,1995.	NarenG		Created original version.
//

#include <nt.h>
#include <ntrtl.h>      // For ASSERT
#include <nturtl.h>     // needed for winbase.h
#include <windows.h>    // Win32 base API's
#include <rpc.h>
#include <ntseapi.h>
#include <ntlsa.h>
#include <ntsam.h>
#include <ntsamp.h>
#include <nturtl.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <lm.h>
#include <lmsvc.h>
#include <raserror.h>
#include <mprapip.h>
#include <mprerror.h>
#include <dimsvc.h>

DWORD
DimRPCBind(
	IN  LPWSTR 	            lpwsServerName,
	OUT HANDLE *            phDimServer
);

DWORD APIENTRY
MprAdminInterfaceSetCredentialsEx(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwLevel,
    IN      LPBYTE                  lpbBuffer
);
    
PVOID
MprAdminAlloc(
    IN DWORD dwSize)
{
    return MIDL_user_allocate(dwSize);
}

VOID
MprAdminFree(
    IN PVOID pvData)
{
    MIDL_user_free(pvData);
}

//**
//
// Call:        RasAdminIsServiceRunning
//
// Returns:     TRUE - Service is running.
//              FALSE - Servicis in not running.
//
//
// Description: Checks to see of Remote Access Service is running on the
//              remote machine
//
BOOL
RasAdminIsServiceRunning(
    IN  LPWSTR  lpwsServerName
)
{
    SC_HANDLE       hSM = NULL, hRemoteAccess = NULL, hRouter = NULL;
    DWORD           dwErr = NO_ERROR;
    BOOL            fIsRouterRunning = FALSE, bOk = FALSE;
    SERVICE_STATUS  Status;

    do
    {
        // Get a handle to the service controller
        //
        hSM = OpenSCManager(
                lpwsServerName,
                NULL,
                GENERIC_READ);
        if (hSM == NULL)
        {
            break;
        }

        // Open the remoteaccess service
        //
        hRemoteAccess = OpenService(
                            hSM,
                            L"RemoteAccess",
                            SERVICE_QUERY_STATUS);
        if (hRemoteAccess == NULL)
        {
            break;
        }

        // If remoteaccess service is running, return
        // true
        //
        bOk = QueryServiceStatus(
                hRemoteAccess,
                &Status);
        if (bOk && (Status.dwCurrentState == SERVICE_RUNNING))
        {
            fIsRouterRunning = TRUE;
            break;
        }

        // Otherwise, see if the router service is running.
        //
        hRouter = OpenService(
                    hSM,
                    L"Router",
                    SERVICE_QUERY_STATUS);
        if (hRouter == NULL)
        {
            break;
        }

        // If router service is running, return
        // true
        //
        bOk = QueryServiceStatus(
                hRouter,
                &Status);
        if (bOk && (Status.dwCurrentState == SERVICE_RUNNING))
        {
            fIsRouterRunning = TRUE;
            break;
        }

    } while (FALSE);

    // Cleanup
    {
        if (hRemoteAccess)
        {
            CloseServiceHandle(hRemoteAccess);
        }
        if (hRouter)
        {
            CloseServiceHandle(hRouter);
        }
        if (hSM)
        {
            CloseServiceHandle(hSM);
        }
    }

    return fIsRouterRunning;
}

//**
//
// Call:	    RasAdminServerConnect
//
// Returns:	    NO_ERROR - success
//		        non-zero returns from the DimRPCBind routine.
//		
//
// Description: This is the DLL entrypoint for RasAdminServerConnect
//
DWORD
RasAdminServerConnect(
    IN  LPWSTR 		        lpwsServerName,
    OUT RAS_SERVER_HANDLE * phRasServer
)
{
    //
    // Bind with the server
    //

    return( DimRPCBind( lpwsServerName, phRasServer ) );
}

//**
//
// Call:	    RasAdminServerDisconnect
//
// Returns:	    none.
//
// Description: This is the DLL entrypoint for RasAdminServerDisconnect
//
VOID
RasAdminServerDisconnect(
	IN RAS_SERVER_HANDLE    hRasServer
)
{
    RpcBindingFree( (handle_t *)&hRasServer );
}

//**
//
// Call:	    RasAdminBufferFree
//
// Returns:	    none
//
// Description: This is the DLL entrypoint for RasAdminBufferFree
//
DWORD
RasAdminBufferFree(
	IN PVOID		pBuffer
)
{
    if ( pBuffer == NULL )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    MIDL_user_free( pBuffer );

    return( NO_ERROR );
}

//**
//
// Call:	    RasAdminConnectionEnum
//
// Returns:	    NO_ERROR	- success
//		        ERROR_INVALID_PARAMETER
//		        non-zero returns from RRasAdminConnectionEnum
//
// Description: This is the DLL entry point for RasAdminConnectionEnum.
//
DWORD APIENTRY
RasAdminConnectionEnum(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      DWORD                   dwLevel,
    OUT     LPBYTE *                lplpbBuffer,        // RAS_CONNECTION_0
    IN      DWORD                   dwPrefMaxLen,
    OUT     LPDWORD                 lpdwEntriesRead,
    OUT     LPDWORD                 lpdwTotalEntries,
    IN      LPDWORD                 lpdwResumeHandle    OPTIONAL
)
{
    DWORD			            dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    // Validate parameters
    //
    if (dwPrefMaxLen == 0)
    {
        return ERROR_MORE_DATA;
    }

    //
    // Touch all pointers
    //

    try
    {
	    *lplpbBuffer 	  = NULL;
	    *lpdwEntriesRead  = 0;
	    *lpdwTotalEntries = 0;

	    if ( lpdwResumeHandle )
        {
	        *lpdwResumeHandle = *lpdwResumeHandle;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        DWORD dwRetval = NO_ERROR;
	    dwRetCode = RRasAdminConnectionEnum(
                            hRasServer,
                            dwLevel,
    					    &InfoStruct,
					        dwPrefMaxLen,
                            lpdwEntriesRead,
					        lpdwTotalEntries,
					        lpdwResumeHandle );

	    if ( InfoStruct.pBuffer != NULL )
        {

            dwRetval = 
                MprThunkConnection_WtoH(
                    dwLevel,
                    InfoStruct.pBuffer,
                    InfoStruct.dwBufferSize,
                    *lpdwEntriesRead,
                    MprAdminAlloc,
                    MprAdminFree,
                    lplpbBuffer);
	    }

            if (dwRetval != NO_ERROR)
                dwRetCode = dwRetval;

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
	    dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:	    RasAdminPortEnum
//
// Returns:	    NO_ERROR	- success
//		        ERROR_INVALID_PARAMETER
//		        non-zero returns from RRasAdminPortEnum
//
// Description: This is the DLL entry point for RasAdminPortEnum.
//
DWORD APIENTRY
RasAdminPortEnum(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      DWORD                   dwLevel,
    IN      HANDLE                  hRasConnection,
    OUT     LPBYTE *                lplpbBuffer,        // RAS_PORT_0
    IN      DWORD                   dwPrefMaxLen,
    OUT     LPDWORD                 lpdwEntriesRead,
    OUT     LPDWORD                 lpdwTotalEntries,
    IN      LPDWORD                 lpdwResumeHandle    OPTIONAL
)
{
    DWORD			            dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Touch all pointers
    //

    try
    {
	    *lplpbBuffer 	  = NULL;
	    *lpdwEntriesRead  = 0;
	    *lpdwTotalEntries = 0;

	    if ( lpdwResumeHandle )
        {
	        *lpdwResumeHandle = *lpdwResumeHandle;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
	    dwRetCode = RRasAdminPortEnum(
                            hRasServer,
                            dwLevel,
                            PtrToUlong(hRasConnection),
    					    &InfoStruct,
					        dwPrefMaxLen,
                            lpdwEntriesRead,
					        lpdwTotalEntries,
					        lpdwResumeHandle );

	    if ( InfoStruct.pBuffer != NULL )
        {
            dwRetCode = 
                MprThunkPort_WtoH(
                    dwLevel,
                    InfoStruct.pBuffer,
                    InfoStruct.dwBufferSize,
                    *lpdwEntriesRead,
                    MprAdminAlloc,
                    MprAdminFree,
                    lplpbBuffer);          
	    }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
	    dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:	    RasAdminConnectionGetInfo
//
// Returns:	    NO_ERROR	- success
//		        ERROR_INVALID_PARAMETER
//		        non-zero return codes from RRasAdminConnectionGetInfo
//
// Description: This is the DLL entrypoint for RasAdminConnectionGetInfo
//
DWORD APIENTRY
RasAdminConnectionGetInfo(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      DWORD                   dwLevel,
	IN      HANDLE	                hRasConnection,
    OUT     LPBYTE *                lplpbBuffer
)
{
    DWORD	                    dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
		*lplpbBuffer = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
	
	    dwRetCode = RRasAdminConnectionGetInfo(
                            hRasServer,
                            dwLevel,
                            PtrToUlong(hRasConnection),
					        &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
	    dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( dwRetCode == NO_ERROR )
    {
	    if ( InfoStruct.pBuffer != NULL )
        {
            MprThunkConnection_WtoH(
                dwLevel,
                InfoStruct.pBuffer,
                InfoStruct.dwBufferSize,
                1,
                MprAdminAlloc,
                MprAdminFree,
                lplpbBuffer);          
	    }
    }

    return( dwRetCode );
}

//**
//
// Call:	    RasAdminPortGetInfo
//
// Returns:	    NO_ERROR	- success
//		        ERROR_INVALID_PARAMETER
//		        non-zero return codes from RRasAdminPortGetInfo
//
// Description: This is the DLL entrypoint for RasAdminPortGetInfo
//
DWORD APIENTRY
RasAdminPortGetInfo(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      DWORD                   dwLevel,
	IN      HANDLE	                hPort,
	OUT     LPBYTE *                lplpbBuffer
)
{
    DWORD	                    dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
    	*lplpbBuffer = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
	    dwRetCode = RRasAdminPortGetInfo(
                                    hRasServer,
                                    dwLevel,
                                    PtrToUlong(hPort),
					                &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
	    dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( dwRetCode == NO_ERROR )
    {
	    if ( InfoStruct.pBuffer != NULL )
        {
                MprThunkPort_WtoH(
                    dwLevel,
                    InfoStruct.pBuffer,
                    InfoStruct.dwBufferSize,
                    1,
                    MprAdminAlloc,
                    MprAdminFree,
                    lplpbBuffer);          
	    }
    }

    return( dwRetCode );
}

//**
//
// Call:        RasAdminGetErrorString
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRasAdminGetErrorString
//
// Description: This is the DLL entrypoint for RasAdminGetErrorString
//
DWORD APIENTRY
RasAdminGetErrorString(
    IN      DWORD                   dwError,
    OUT     LPWSTR *                lplpwsErrorString
)
{
    return( MprAdminGetErrorString( dwError, lplpwsErrorString ) );
}

//**
//
// Call:	    RasAdminConnectionClearStats
//
// Returns:	    NO_ERROR	- success
//		        ERROR_INVALID_PARAMETER
//		        non-zero return codes from RRasAdminConnectionClearStats
//
// Description: This is the DLL entrypoint for RasAdminConnectionClearStats
//
DWORD APIENTRY
RasAdminConnectionClearStats(
    IN      RAS_SERVER_HANDLE       hRasServer,
	IN      HANDLE	                hRasConnection
)
{
    DWORD	dwRetCode;

    RpcTryExcept
    {
	    dwRetCode = RRasAdminConnectionClearStats(
                                    hRasServer,
                                    PtrToUlong(hRasConnection) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
	    dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:	    RasAdminPortClearStats
//
// Returns:	    NO_ERROR	- success
//		        ERROR_INVALID_PARAMETER
//		        non-zero return codes from RRasAdminPortClearStats
//
// Description: This is the DLL entrypoint for RasAdminPortClearStats
//
DWORD APIENTRY
RasAdminPortClearStats(
    IN      RAS_SERVER_HANDLE       hRasServer,
	IN      HANDLE	                hPort
)
{
    DWORD	dwRetCode;

    RpcTryExcept
    {
	    dwRetCode = RRasAdminPortClearStats( hRasServer, PtrToUlong(hPort) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
	    dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:	    RasAdminPortReset
//
// Returns:	    NO_ERROR	- success
//		        ERROR_INVALID_PARAMETER
//		        non-zero return codes from RRasAdminPortReset
//
// Description: This is the DLL entrypoint for RasAdminPortReset
//
DWORD APIENTRY
RasAdminPortReset(
    IN      RAS_SERVER_HANDLE       hRasServer,
	IN      HANDLE	                hPort
)
{
    DWORD	dwRetCode;

    RpcTryExcept
    {
	    dwRetCode = RRasAdminPortReset( hRasServer, PtrToUlong(hPort) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
	    dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        RasAdminPortDisconnect
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRasAdminPortDisconnect
//
// Description: This is the DLL entrypoint for RasAdminPortDisconnect
//
DWORD APIENTRY
RasAdminPortDisconnect(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      HANDLE                  hPort
)
{
    DWORD   dwRetCode;

    RpcTryExcept
    {
        dwRetCode = RRasAdminPortDisconnect( hRasServer, PtrToUlong(hPort) );
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminSendUserMessage
//
// Returns:     NO_ERROR         - Success
//              Non-zero returns - Failure
//
// Description:
//
DWORD APIENTRY
MprAdminSendUserMessage(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hRasConnection,
    IN      LPWSTR                  lpwszMessage
)
{
    DWORD   dwRetCode;
    BOOL    fZeroLengthMessage = FALSE;

    //
    // make sure the buffer is valid, and enough bytes are really available
    //

    try
    {
        if ( wcslen( lpwszMessage ) == 0 )
        {
            fZeroLengthMessage = TRUE;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    if ( fZeroLengthMessage )
    {
        return( NO_ERROR );
    }

    RpcTryExcept
    {
        dwRetCode = RRasAdminSendUserMessage(
                                    hMprServer,
                                    PtrToUlong(hRasConnection),
                                    lpwszMessage );
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );

}

//**
//
// Call:        MprAdminServerGetInfo
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RMprAdminServerGetInfo
//
// Description: This is the DLL entrypoint for MprAdminServerGetInfo
//
DWORD APIENTRY
MprAdminServerGetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      DWORD                   dwLevel,
    IN      LPBYTE *                lplpbBuffer
)
{
    DWORD                       dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
    	*lplpbBuffer = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMprAdminServerGetInfo(
                                    hMprServer,
                                    dwLevel,
					                &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( dwRetCode == NO_ERROR )
    {
	    if ( InfoStruct.pBuffer != NULL )
        {
            *lplpbBuffer = InfoStruct.pBuffer;
	    }
    }

    return( dwRetCode );
}


DWORD APIENTRY
MprAdminServerSetCredentials(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      DWORD                   dwLevel,
    IN      LPBYTE                  lpbBuffer
)
{
    if(0 != dwLevel)
    {   
        return ERROR_NOT_SUPPORTED;
    }

    return MprAdminInterfaceSetCredentialsEx(
                    hMprServer,
                    NULL,
                    2,
                    lpbBuffer);
}

DWORD APIENTRY
MprAdminServerGetCredentials(
        IN  MPR_SERVER_HANDLE       hMprServer,
        IN  DWORD                   dwLevel,
        IN  LPBYTE *                lplpbBuffer)
{
    if (0 != dwLevel)
        return ERROR_NOT_SUPPORTED;
        
    if (NULL == lplpbBuffer)
    {
        return ERROR_INVALID_PARAMETER;

    }
    
    return MprAdminInterfaceGetCredentialsEx(
                hMprServer,
                NULL,
                2,
                lplpbBuffer);
}

//**
//
// Call:        MprAdminIsServiceRunning
//
// Returns:     TRUE - Service is running.
//              FALSE - Servicis in not running.
//
//
// Description: Checks to see of Remote Access Service is running on the
//              remote machine
//
BOOL
MprAdminIsServiceRunning(
    IN  LPWSTR  lpwsServerName
)
{
    BOOL fServiceStarted;
    DWORD dwErr;
    HANDLE hServer;

    // First query the service controller to see whether
    // the service is running.
    //
    fServiceStarted = RasAdminIsServiceRunning( lpwsServerName );
    if ( fServiceStarted == FALSE )
    {
        return FALSE;
    }

    // pmay: 209235
    //
    // Even if the service controller says that the service is
    // started, it may still be initializing.  
    //

    // Initalize
    {
        fServiceStarted = FALSE;
        dwErr = NO_ERROR;
        hServer = NULL;
    }

    do 
    {
        // Connect to the service rpc
        //
        dwErr = MprAdminServerConnect(
                    lpwsServerName,
                    &hServer);
        if (dwErr != NO_ERROR)
        {
            break;
        }

        // Return TRUE iff the service has been 
        // running for more than zero seconds
        //
        fServiceStarted = TRUE;
        
    } while (FALSE);

    // Cleanup
    {
        if (hServer)
        {
            MprAdminServerDisconnect( hServer );
        }
    }
    
    return fServiceStarted;
}

//
// Call:        MprAdminServerConnect
//
// Returns:     NO_ERROR - success
//              non-zero returns from the DimRPCBind routine.
//
//
// Description: This is the DLL entrypoint for RouterInterfaceServerConnect
//
DWORD
MprAdminServerConnect(
    IN  LPWSTR                  lpwsServerName,
    OUT MPR_SERVER_HANDLE *     phMprServer
)
{
    DWORD dwErr = NO_ERROR;
    MPR_SERVER_0 * pMprServer0 = NULL;

    if (phMprServer == NULL)
        return RPC_S_INVALID_BINDING;
        
    do 
    {
        //
        // Bind with the server
        //
        dwErr = DimRPCBind( lpwsServerName, phMprServer );
        
        if ( dwErr != NO_ERROR )
        {
            break;
        }

        // 
        // pmay: 209235
        //
        // Only return success if the service is running.
        //
        dwErr = MprAdminServerGetInfo(
                    *phMprServer,
                    0,
                    (LPBYTE*)&pMprServer0);
                    
        if (dwErr != NO_ERROR)
        {
            break;
        }
        
    } while (FALSE);

    // Cleanup
    {
        if ( pMprServer0 != NULL)
        {
            MprAdminBufferFree( pMprServer0 );
        }

        if (    (dwErr != NO_ERROR )
            &&  (NULL != *phMprServer))
        {
            MprAdminServerDisconnect( *phMprServer );
            *phMprServer = NULL;
        }
    }

    return dwErr;
}

//**
//
// Call:        MprAdminServerDisconnect
//
// Returns:     none.
//
// Description: This is the DLL entrypoint for RouterInterfaceServerDisconnect
//
VOID
MprAdminServerDisconnect(
    IN MPR_SERVER_HANDLE    hMprServer
)
{
    if (hMprServer)
        RpcBindingFree( (handle_t *)&hMprServer );
}

//**
//
// Call:        MprAdminBufferFree
//
// Returns:     none
//
// Description: This is the DLL entrypoint for RouterInterfaceBufferFree
//
DWORD
MprAdminBufferFree(
    IN PVOID        pBuffer
)
{
    if ( pBuffer == NULL )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    MIDL_user_free( pBuffer );

    return( NO_ERROR );
}

//**
//
// Call:        MprAdminTransportCreate
//
// Returns:     NO_ERROR         - Success
//              Non-zero returns - Failure
//
// Description: This is the DLL entrypoint for MprAdminTransportCreate
//
DWORD APIENTRY
MprAdminTransportCreate(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      DWORD                   dwTransportId,
    IN      LPWSTR                  lpwsTransportName           OPTIONAL,
    IN      LPBYTE                  pGlobalInfo,
    IN      DWORD                   dwGlobalInfoSize,
    IN      LPBYTE                  pClientInterfaceInfo        OPTIONAL,
    IN      DWORD                   dwClientInterfaceInfoSize   OPTIONAL,
    IN      LPWSTR                  lpwsDLLPath
)
{
    DWORD                       dwRetCode;
    DIM_INTERFACE_CONTAINER     InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    try
    {
        if ( pGlobalInfo != NULL )
        {
            InfoStruct.dwGlobalInfoSize     = dwGlobalInfoSize;
            InfoStruct.pGlobalInfo          = pGlobalInfo;
        }

        if ( pClientInterfaceInfo != NULL )
        {
            InfoStruct.dwInterfaceInfoSize  = dwClientInterfaceInfoSize;
            InfoStruct.pInterfaceInfo       = pClientInterfaceInfo;
        }

    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceTransportCreate(
                                    hMprServer,
                                    dwTransportId,
                                    lpwsTransportName,
                                    &InfoStruct,
                                    lpwsDLLPath );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminTransportSetInfo
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from
//              RRouterInterfaceTransportSetGlobalInfo
//
// Description: This is the DLL entrypoint for
//              RouterInterfaceTransportSetGlobalInfo
//
DWORD APIENTRY
MprAdminTransportSetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      DWORD                   dwTransportId,
    IN      LPBYTE                  pGlobalInfo                 OPTIONAL,
    IN      DWORD                   dwGlobalInfoSize,
    IN      LPBYTE                  pClientInterfaceInfo        OPTIONAL,
    IN      DWORD                   dwClientInterfaceInfoSize
)
{
    DWORD                       dwRetCode;
    DIM_INTERFACE_CONTAINER     InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    if ( ( pGlobalInfo == NULL ) && ( pClientInterfaceInfo == NULL ) )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        if ( pGlobalInfo != NULL )
        {
            InfoStruct.dwGlobalInfoSize     = dwGlobalInfoSize;
            InfoStruct.pGlobalInfo          = pGlobalInfo;
        }

        if ( pClientInterfaceInfo != NULL )
        {
            InfoStruct.dwInterfaceInfoSize  = dwClientInterfaceInfoSize;
            InfoStruct.pInterfaceInfo       = pClientInterfaceInfo;
        }

    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceTransportSetGlobalInfo(
                                    hMprServer,
                                    dwTransportId,
                                    &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminTransportGetInfo
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from
//              RRouterInterfaceTransportGetGlobalInfo
//
// Description: This is the DLL entrypoint for
//              RouterInterfaceTransportGetGlobalInfo
//
DWORD APIENTRY
MprAdminTransportGetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      DWORD                   dwTransportId,
    OUT     LPBYTE *                ppGlobalInfo                    OPTIONAL,
    OUT     LPDWORD                 lpdwGlobalInfoSize              OPTIONAL,
    OUT     LPBYTE *                ppClientInterfaceInfo           OPTIONAL,
    OUT     LPDWORD                 lpdwClientInterfaceInfoSize     OPTIONAL
)
{
    DWORD                       dwRetCode;
    DIM_INTERFACE_CONTAINER     InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    if ( ( ppGlobalInfo == NULL ) && ( ppClientInterfaceInfo  == NULL ) )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        if ( ppGlobalInfo != NULL )
        {
            *ppGlobalInfo = NULL;
            InfoStruct.fGetGlobalInfo = TRUE;
        }

        if ( ppClientInterfaceInfo != NULL )
        {
            *ppClientInterfaceInfo = NULL;
            InfoStruct.fGetInterfaceInfo = TRUE;
        }

    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceTransportGetGlobalInfo(
                                    hMprServer,
                                    dwTransportId,
                                    &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( dwRetCode == NO_ERROR )
    {
	    if ( InfoStruct.pGlobalInfo != NULL )
        {
            if (ppGlobalInfo)
            {
                *ppGlobalInfo = (LPBYTE)(InfoStruct.pGlobalInfo);
            }
            
            if ( lpdwGlobalInfoSize != NULL )
            {
                *lpdwGlobalInfoSize = InfoStruct.dwGlobalInfoSize;
            }
	    }

	    if ( InfoStruct.pInterfaceInfo != NULL )
        {
            if (ppClientInterfaceInfo)
            {
                *ppClientInterfaceInfo = (LPBYTE)(InfoStruct.pInterfaceInfo);
            }
            
            if ( lpdwClientInterfaceInfoSize != NULL )
            {
                *lpdwClientInterfaceInfoSize = InfoStruct.dwInterfaceInfoSize;
            }
	    }
    }

    return( dwRetCode );
}

DWORD APIENTRY
MprAdminDeviceEnum(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      DWORD                   dwLevel,
    OUT     LPBYTE*                 lplpbBuffer,
    OUT     LPDWORD                 lpdwTotalEntries)
{
    DWORD                       dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    if ( dwLevel != 0 )
    {   
        return ERROR_NOT_SUPPORTED;
    }
    
    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *lplpbBuffer = *lplpbBuffer;
        *lpdwTotalEntries = *lpdwTotalEntries;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterDeviceEnum(
                        hMprServer,
                        dwLevel,
                        &InfoStruct,
                        lpdwTotalEntries );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( dwRetCode == NO_ERROR )
    {
        // Assign the return value
        //
        
        *lplpbBuffer = (LPBYTE)(InfoStruct.pBuffer);
    }

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceCreate
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceCreate
//
// Description: This is the DLL entrypoint for RouterInterfaceCreate
//
DWORD APIENTRY
MprAdminInterfaceCreate(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      DWORD                   dwLevel,
    IN      LPBYTE                  lpbBuffer,
    OUT     HANDLE *                phInterface
)
{
    DWORD                       dwRetCode   = NO_ERROR, dwInterface = 0;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *phInterface = INVALID_HANDLE_VALUE;
        *lpbBuffer = *lpbBuffer;

        //
        // Set up the interface information
        //
        dwRetCode = MprThunkInterface_HtoW(
                        dwLevel,
                        lpbBuffer,
                        &InfoStruct.pBuffer,
                        &InfoStruct.dwBufferSize);
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    if ( dwRetCode != NO_ERROR )
    {
        return( dwRetCode );
    }

    RpcTryExcept
    {
        MPRI_INTERFACE_0 *           pMprIf0 =
                                    (MPRI_INTERFACE_0*)InfoStruct.pBuffer;

        if ( pMprIf0->dwIfType == ROUTER_IF_TYPE_TUNNEL1) {
            dwRetCode = NO_ERROR;
        }
        else {
            dwRetCode = RRouterInterfaceCreate(
                                        hMprServer,
                                        dwLevel,
                                        &InfoStruct,
                                        &dwInterface );
            if (dwRetCode == NO_ERROR)
            {
                *phInterface = UlongToPtr(dwInterface);
            }
        }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    MprThunkInterfaceFree( InfoStruct.pBuffer, dwLevel );

    return( dwRetCode );
}

//
// Call:        MprAdminInterfaceGetInfo
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceGetInfo
//
// Description: This is the DLL entrypoint for RouterInterfaceGetInfo
//
DWORD APIENTRY
MprAdminInterfaceGetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwLevel,
    IN      LPBYTE *                lplpbBuffer
)
{
    DWORD                       dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *lplpbBuffer = *lplpbBuffer;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceGetInfo(
                                    hMprServer,
                                    dwLevel,
                                    &InfoStruct,
                                    PtrToUlong(hInterface) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( ( dwRetCode == NO_ERROR ) && ( InfoStruct.pBuffer != NULL ) )
    {
        dwRetCode = 
            MprThunkInterface_WtoH(
                dwLevel,
                InfoStruct.pBuffer,
                InfoStruct.dwBufferSize,
                1,
                MprAdminAlloc,
                MprAdminFree,
                lplpbBuffer);          
    }

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceSetInfo
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceSetInfo
//
// Description: This is the DLL entrypoint for RouterInterfaceSetInfo
//
DWORD APIENTRY
MprAdminInterfaceSetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwLevel,
    IN      LPBYTE                  lpbBuffer
)
{
    DWORD                       dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *lpbBuffer = *lpbBuffer;

        //
        // Set up the interface information
        //
        dwRetCode = MprThunkInterface_HtoW(
                        dwLevel,
                        lpbBuffer,
                        &InfoStruct.pBuffer,
                        &InfoStruct.dwBufferSize);

    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    if ( dwRetCode != NO_ERROR )
    {
        return( dwRetCode );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceSetInfo(
                                    hMprServer,
                                    dwLevel,
                                    &InfoStruct,
                                    PtrToUlong(hInterface) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    MprThunkInterfaceFree( InfoStruct.pBuffer, dwLevel );

    return( dwRetCode );
}

DWORD APIENTRY
MprAdminInterfaceDeviceGetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwIndex,
    IN      DWORD                   dwLevel,
    OUT     LPBYTE*                 lplpBuffer)
{
    DWORD                       dwRetCode = NO_ERROR;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    if ( ( (int) dwLevel < 0 ) || ( dwLevel > 1 ) )
    {
        return ERROR_NOT_SUPPORTED;
    }

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *lplpBuffer = *lplpBuffer;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    if (dwRetCode != NO_ERROR)
    {
        return ( dwRetCode );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceDeviceGetInfo(
                        hMprServer,
                        dwLevel,
                        &InfoStruct,
                        dwIndex,
                        PtrToUlong(hInterface) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    // Process return values
    //
    if ( dwRetCode == NO_ERROR  )
    {
        // Fix any variable length structure pointers
        //
        switch ( dwLevel )
        {
            case 0:
                break;

            case 1:
                {
                    MPR_DEVICE_1* pDev1 = 
                        (MPR_DEVICE_1*)InfoStruct.pBuffer;

                    if ( ( InfoStruct.dwBufferSize != 0 ) &&
                         ( pDev1 != NULL )                && 
                         ( pDev1->szAlternates != NULL ) 
                       )
                    {
                        pDev1->szAlternates = (PWCHAR) (pDev1 + 1);
                    }
                }
                break;
        }

        // Assign the return value
        //
        if ( InfoStruct.dwBufferSize != 0 )
        {
            *lplpBuffer = InfoStruct.pBuffer;
        }            
    }        

    return( dwRetCode );
}

DWORD APIENTRY
MprAdminInterfaceDeviceSetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwIndex,
    IN      DWORD                   dwLevel,
    OUT     LPBYTE                  lpbBuffer)
{
    DWORD                       dwRetCode = NO_ERROR, dwAltSize = 0;
    DIM_INFORMATION_CONTAINER   InfoStruct;
    MPR_DEVICE_0*               pDev0 = (MPR_DEVICE_0*)lpbBuffer;
    MPR_DEVICE_1*               pDev1 = (MPR_DEVICE_1*)lpbBuffer;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *lpbBuffer = *lpbBuffer;

        //
        // Set up the interface information
        //
        switch ( dwLevel )
        {
            case 0:
                InfoStruct.dwBufferSize = sizeof(MPR_DEVICE_0);
                InfoStruct.pBuffer = (LPBYTE)pDev0;
                break;

            case 1:
                dwAltSize = MprUtilGetSizeOfMultiSz(pDev1->szAlternates);
                if ( pDev1->szAlternates == NULL ) 
                {
                    InfoStruct.dwBufferSize = sizeof(MPR_DEVICE_1);
                    InfoStruct.pBuffer = (LPBYTE)pDev1;
                    break;
                }

                InfoStruct.dwBufferSize = sizeof(MPR_DEVICE_1) + dwAltSize;
                InfoStruct.pBuffer = 
                    LocalAlloc(LPTR, InfoStruct.dwBufferSize);

                if ( InfoStruct.pBuffer == NULL )
                {
                    dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
                    break;
                }

                CopyMemory(
                    InfoStruct.pBuffer,
                    pDev1,
                    sizeof(MPR_DEVICE_1));

                ((MPR_DEVICE_1*)InfoStruct.pBuffer)->szAlternates = 
                    (PWCHAR) InfoStruct.pBuffer + sizeof(MPR_DEVICE_1);

                CopyMemory(
                    InfoStruct.pBuffer + sizeof(MPR_DEVICE_1),
                    pDev1->szAlternates,
                    dwAltSize);
                    
                break;

            default:
                dwRetCode = ERROR_NOT_SUPPORTED;
                break;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    if (dwRetCode != NO_ERROR)
    {
        return ( dwRetCode );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceDeviceSetInfo(
                        hMprServer,
                        dwLevel,
                        &InfoStruct,
                        dwIndex,
                        PtrToUlong(hInterface) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( dwLevel == 1 )
    {
        if (InfoStruct.pBuffer == NULL)
        {
            LocalFree( InfoStruct.pBuffer );
        }
    }

    return( dwRetCode );
}


//**
//
// Call:        MprAdminInterfaceGetHandle
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceGetHandle
//
// Description: This is the DLL entrypoint for RouterInterfaceGetHandle
//
DWORD APIENTRY
MprAdminInterfaceGetHandle(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      LPWSTR                  lpwsInterfaceName,
    IN OUT  HANDLE *                phInterface,
    IN      BOOL                    fIncludeClientInterfaces
)
{
    DWORD dwRetCode, dwInterface = 0;

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *phInterface = INVALID_HANDLE_VALUE;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceGetHandle(
                                    hMprServer,
                                    lpwsInterfaceName,
                                    &dwInterface,
                                    (DWORD)fIncludeClientInterfaces );
        if (dwRetCode == NO_ERROR)
        {
            *phInterface = UlongToPtr(dwInterface);
        }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceDelete
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceDelete
//
// Description: This is the DLL entrypoint for RouterInterfaceDelete
//
DWORD APIENTRY
MprAdminInterfaceDelete(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface
)
{
    DWORD   dwRetCode;

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceDelete(
                                     hMprServer,
                                     PtrToUlong(hInterface) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceTransportRemove
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceTransportRemove
//
// Description: This is the DLL entrypoint for RouterInterfaceTransportRemove
//
DWORD APIENTRY
MprAdminInterfaceTransportRemove(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwTransportId
)
{
    DWORD   dwRetCode;

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceTransportRemove(
                                     hMprServer,
                                     PtrToUlong(hInterface),
                                     dwTransportId );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:	    MprAdminInterfaceEnum
//
// Returns:	    NO_ERROR	- success
//		        ERROR_INVALID_PARAMETER
//		        non-zero returns from RRouterInterfaceEnum
//
// Description: This is the DLL entry point for RouterInterfaceEnum.
//
DWORD APIENTRY
MprAdminInterfaceEnum(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      DWORD                   dwLevel,
    OUT     LPBYTE *                lplpbBuffer,
    IN      DWORD                   dwPrefMaxLen,
    OUT     LPDWORD                 lpdwEntriesRead,
    OUT     LPDWORD                 lpdwTotalEntries,
    IN      LPDWORD                 lpdwResumeHandle    OPTIONAL
)
{
    DWORD			            dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    if (!hMprServer)
        return RPC_S_INVALID_BINDING;
        
    if (!lplpbBuffer || !lpdwEntriesRead || !lpdwTotalEntries)
    {
        return ERROR_INVALID_PARAMETER;
    }

    if (dwLevel!=0)
        return ERROR_NOT_SUPPORTED;
        
    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Touch all pointers
    //

    try
    {
	    *lplpbBuffer 	      = NULL;
	    *lpdwEntriesRead  = 0;
	    *lpdwTotalEntries = 0;

	    if ( lpdwResumeHandle )
        {
	        *lpdwResumeHandle = *lpdwResumeHandle;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
	    dwRetCode = RRouterInterfaceEnum(
                            hMprServer,
                            dwLevel,
    					    &InfoStruct,
					        dwPrefMaxLen,
                            lpdwEntriesRead,
					        lpdwTotalEntries,
					        lpdwResumeHandle );

	    if ( InfoStruct.pBuffer != NULL)
        {
            DWORD dwRetCodeTmp;
            
            dwRetCodeTmp = 
                MprThunkInterface_WtoH(
                    dwLevel,
                    InfoStruct.pBuffer,
                    InfoStruct.dwBufferSize,
                    *lpdwEntriesRead,
                    MprAdminAlloc,
                    MprAdminFree,
                    lplpbBuffer);
                    
            if (dwRetCodeTmp != NO_ERROR)
                dwRetCode = dwRetCodeTmp;
	    }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
	    dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceTransportGetInfo
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceTransportGetInfo
//
// Description: This is the DLL entrypoint for RouterInterfaceTransportGetInfo
//
DWORD APIENTRY
MprAdminInterfaceTransportGetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwTransportId,
    OUT     LPBYTE *                ppInterfaceInfo,
    OUT     LPDWORD                 lpdwInterfaceInfoSize
)
{
    DWORD                       dwRetCode;
    DIM_INTERFACE_CONTAINER     InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    if ( ppInterfaceInfo == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        if ( ppInterfaceInfo != NULL )
        {
            *ppInterfaceInfo = NULL;
            InfoStruct.fGetInterfaceInfo = TRUE;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceTransportGetInfo(
                                    hMprServer,
                                    PtrToUlong(hInterface),
                                    dwTransportId,
                                    &InfoStruct );


    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( dwRetCode == NO_ERROR )
    {
        *ppInterfaceInfo = (LPBYTE)(InfoStruct.pInterfaceInfo);

        if ( lpdwInterfaceInfoSize != NULL )
        {
            *lpdwInterfaceInfoSize = InfoStruct.dwInterfaceInfoSize;
        }
    }

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceTransportAdd
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceTransportAdd
//
// Description: This is the DLL entrypoint for RouterInterfaceTransportAdd
//
DWORD APIENTRY
MprAdminInterfaceTransportAdd(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwTransportId,
    IN      LPBYTE                  pInterfaceInfo,
    IN      DWORD                   dwInterfaceInfoSize
)
{
    DWORD                       dwRetCode;
    DIM_INTERFACE_CONTAINER     InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    if ( pInterfaceInfo == NULL )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        if ( pInterfaceInfo != NULL )
        {
            InfoStruct.pInterfaceInfo       = pInterfaceInfo;
            InfoStruct.dwInterfaceInfoSize  = dwInterfaceInfoSize;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceTransportAdd(
                                    hMprServer,
                                    PtrToUlong(hInterface),
                                    dwTransportId,
                                    &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceTransportSetInfo
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceTransportSetInfo
//
// Description: This is the DLL entrypoint for RouterInterfaceTransportSetInfo
//
DWORD APIENTRY
MprAdminInterfaceTransportSetInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwTransportId,
    IN      LPBYTE                  pInterfaceInfo          OPTIONAL,
    IN      DWORD                   dwInterfaceInfoSize
)
{
    DWORD                       dwRetCode;
    DIM_INTERFACE_CONTAINER     InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    if ( pInterfaceInfo == NULL )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        if ( pInterfaceInfo != NULL )
        {
            InfoStruct.dwInterfaceInfoSize  = dwInterfaceInfoSize;
            InfoStruct.pInterfaceInfo       = pInterfaceInfo;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceTransportSetInfo(
                                    hMprServer,
                                    PtrToUlong(hInterface),
                                    dwTransportId,
                                    &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceUpdateRoutes
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from
//
// Description: This is the DLL entrypoint for RouterInterfaceUpdateRoutes
//
//
DWORD APIENTRY
MprAdminInterfaceUpdateRoutes(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hDimInterface,
    IN      DWORD                   dwPid,
    IN      HANDLE                  hEvent
)
{
    DWORD                   dwRetCode;
    DWORD                   dwCurrentProcessId = GetCurrentProcessId();

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceUpdateRoutes(
                                    hMprServer,
                                    PtrToUlong(hDimInterface),
                                    dwPid,
                                    (ULONG_PTR) hEvent,
                                    dwCurrentProcessId );
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceQueryUpdateResult
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from
//
// Description: This is the DLL entrypoint for RouterInterfaceQueryUpdateResult
//
DWORD APIENTRY
MprAdminInterfaceQueryUpdateResult(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hDimInterface,
    IN      DWORD                   dwPid,
    OUT     LPDWORD                 lpdwUpdateResult
)
{
    DWORD                 dwRetCode;

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *lpdwUpdateResult = 0;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceQueryUpdateResult(
                                    hMprServer,
                                    PtrToUlong(hDimInterface),
                                    dwPid,
                                    lpdwUpdateResult );
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminGetErrorString
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//
// Description: This is the DLL entrypoint for MprAdminGetErrorString
//
DWORD APIENTRY
MprAdminGetErrorString(
    IN      DWORD       dwError,
    OUT     LPWSTR *    lplpwsErrorString
)
{
    DWORD       dwRetCode       = NO_ERROR;
    DWORD       dwFlags         = FORMAT_MESSAGE_ALLOCATE_BUFFER;
    DWORD       dwBufferSize;
    HINSTANCE   hDll            = NULL;

    if ( ( ( dwError >= RASBASE ) && ( dwError <= RASBASEEND ) ) ||
         ( ( dwError >= ROUTEBASE ) && ( dwError <= ROUTEBASEEND ) ) )
    {
        dwFlags |= FORMAT_MESSAGE_FROM_HMODULE;
        hDll=LoadLibrary(TEXT("mprmsg.dll") );

        if ( hDll == NULL )
        {
            return( GetLastError() );
        }
    }
    else
    {
        dwFlags |= FORMAT_MESSAGE_FROM_SYSTEM;
    }

    dwRetCode = FormatMessage(  dwFlags,
                                hDll,
                                dwError,
                                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                                (LPWSTR)lplpwsErrorString,
                                0,
                                NULL );

    if ( dwRetCode == 0 )
    {
        dwRetCode = GetLastError();
        if ( hDll != NULL )
            FreeLibrary( hDll );
        return dwRetCode;
    }
    
    if ( hDll != NULL )
    {
        FreeLibrary( hDll );
    }

    return( NO_ERROR );
}

//**
//
// Call:        MprAdminInterfaceConnect
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceConnect
//
// Description: This is the DLL entrypoint for RouterInterfaceConnect
//
DWORD APIENTRY
MprAdminInterfaceConnect(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hDimInterface,
    IN      HANDLE                  hEvent,
    IN      BOOL                    fBlocking
)
{
    DWORD                   dwRetCode;
    DWORD                   dwCurrentProcessId = GetCurrentProcessId();

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceConnect(
                                    hMprServer,
                                    PtrToUlong(hDimInterface),
                                    (ULONG_PTR)hEvent,
                                    (DWORD)fBlocking,
                                    dwCurrentProcessId );
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceDisconnect
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceDisconnect
//
// Description: This is the DLL entrypoint for RouterInterfaceDisconnect
//
DWORD APIENTRY
MprAdminInterfaceDisconnect(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hDimInterface
)
{
    DWORD                   dwRetCode;

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceDisconnect(
                                    hMprServer,
                                    PtrToUlong(hDimInterface) );
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminInterfaceUpdatePhonebookInfo
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RRouterInterfaceUpdatePhonebookInfo
//
// Description: This is the DLL entrypoint for
//              RouterInterfaceUpdatePhonebookInfo
//
DWORD APIENTRY
MprAdminInterfaceUpdatePhonebookInfo(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hDimInterface
)
{
    DWORD                   dwRetCode;

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceUpdatePhonebookInfo(
                                    hMprServer,
                                    PtrToUlong(hDimInterface) );
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

DWORD APIENTRY
MprAdminInterfaceSetCredentialsEx(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwLevel,
    IN      LPBYTE                  lpbBuffer)
{
    DWORD                       dwRetCode = NO_ERROR;
    DIM_INFORMATION_CONTAINER   InfoStruct;
    MPR_CREDENTIALSEXI* pCredsI = NULL;                            

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        //
        // Set up the interface information
        //
        switch ( dwLevel )
        {
            case 0:
            {
                MPR_CREDENTIALSEX_0* pCredsEx0 =
                            (MPR_CREDENTIALSEX_0*)lpbBuffer;

                dwRetCode = MprThunkCredentials_HtoW(
                                dwLevel,
                                (PBYTE) pCredsEx0,
                                MprThunkAlloc,
                                &InfoStruct.dwBufferSize,
                                &InfoStruct.pBuffer);
                                            
                break;
            }
            case 1:
            case 2:
            {
                MPR_CREDENTIALSEX_1* pCredsEx1 =
                                (MPR_CREDENTIALSEX_1 *)lpbBuffer;
                                
                dwRetCode = MprThunkCredentials_HtoW(
                                    dwLevel,
                                    (PBYTE) pCredsEx1,
                                    MprThunkAlloc,
                                    &InfoStruct.dwBufferSize,
                                    &InfoStruct.pBuffer);

                break;
            }
            
            default:
                dwRetCode = ERROR_NOT_SUPPORTED;
                break;
        }
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    if (dwRetCode != NO_ERROR)
    {
        return ( dwRetCode );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceSetCredentialsEx(
                        hMprServer,
                        dwLevel,
                        &InfoStruct,
                        PtrToUlong(hInterface) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    if ( dwLevel == 0 )
    {
        if (InfoStruct.pBuffer == NULL)
        {
            ZeroMemory(InfoStruct.pBuffer, InfoStruct.dwBufferSize);
            MprThunkFree( InfoStruct.pBuffer );
        }
    }

    return( dwRetCode );
}

DWORD APIENTRY
MprAdminInterfaceGetCredentialsEx(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hInterface,
    IN      DWORD                   dwLevel,
    IN      LPBYTE *                lplpbBuffer)
{
    DWORD                       dwRetCode;
    DIM_INFORMATION_CONTAINER   InfoStruct;

    ZeroMemory( &InfoStruct, sizeof( InfoStruct ) );

    if (    (dwLevel != 0)
        &&  (dwLevel != 1)
        &&  (dwLevel != 2))
    {
        return ERROR_NOT_SUPPORTED;
    }
    
    //
    // Make sure that all pointers passed in are valid
    //
    try
    {
        *lplpbBuffer = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRouterInterfaceGetCredentialsEx(
                        hMprServer,
                        dwLevel,
                        &InfoStruct,
                        PtrToUlong(hInterface) );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    //
    // Assign the return value
    //
    if ( dwRetCode == NO_ERROR )
    {
        *lplpbBuffer = NULL;
        
        switch(dwLevel)
        {
            case 0:
            {
                MPR_CREDENTIALSEXI *pCredsI = (MPR_CREDENTIALSEXI *)
                                                InfoStruct.pBuffer;
                MPR_CREDENTIALSEX_0* pCred0 = NULL;

                dwRetCode = MprThunkCredentials_WtoH(
                                    dwLevel,
                                    pCredsI,
                                    MprAdminAlloc,
                                    (PBYTE *) &pCred0);
                                    
                if(NULL != InfoStruct.pBuffer)
                {
                    ZeroMemory(InfoStruct.pBuffer, InfoStruct.dwBufferSize);
                    MprAdminFree(InfoStruct.pBuffer);
                }

                *lplpbBuffer = (PBYTE) pCred0;

                break;
            }
            case 1:
            case 2:
            {
                MPR_CREDENTIALSEXI *pCredsI = (MPR_CREDENTIALSEXI *)
                                                InfoStruct.pBuffer;
                MPR_CREDENTIALSEX_1* pCred1 = NULL;

                dwRetCode = MprThunkCredentials_WtoH(
                                    dwLevel,
                                    pCredsI,
                                    MprAdminAlloc,
                                    (PBYTE *) &pCred1);

                if(NULL != InfoStruct.pBuffer)
                {
                    ZeroMemory(InfoStruct.pBuffer, InfoStruct.dwBufferSize);
                    MprAdminFree(InfoStruct.pBuffer);
                }

                *lplpbBuffer = (PBYTE) pCred1;

                break;
            }
        }
    }

    return( dwRetCode );
}

//**
//
// Call:        MprAdminRegisterConnectionNotification
//
// Returns:     NO_ERROR         - Success
//              Non-zero returns - Failure
//
// Description:
//
DWORD APIENTRY
MprAdminRegisterConnectionNotification(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hEventNotification
)
{
    DWORD dwRetCode;
    DWORD dwCurrentProcessId = GetCurrentProcessId();

    if ( ( hEventNotification == INVALID_HANDLE_VALUE ) ||
         ( hEventNotification == NULL ) )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRasAdminConnectionNotification(
                                    hMprServer,
                                    TRUE,
                                    dwCurrentProcessId,
                                    (ULONG_PTR) hEventNotification );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );

}

//**
//
// Call:        MprAdminDeregisterConnectionNotification
//
// Returns:     NO_ERROR         - Success
//              Non-zero returns - Failure
//
// Description:
//
DWORD APIENTRY
MprAdminDeregisterConnectionNotification(
    IN      MPR_SERVER_HANDLE       hMprServer,
    IN      HANDLE                  hEventNotification
)
{
    DWORD dwRetCode;

    if ( ( hEventNotification == INVALID_HANDLE_VALUE ) ||
         ( hEventNotification == NULL ) )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RRasAdminConnectionNotification(
                                    hMprServer,
                                    FALSE,
                                    0,
                                    (ULONG_PTR)hEventNotification );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//
// Call:        MprAdminMIBServerConnect
//
// Returns:     NO_ERROR - success
//              non-zero returns from the DimRPCBind routine.
//
//
// Description: This is the DLL entrypoint for MIBServerConnect
//
DWORD
MprAdminMIBServerConnect(
    IN  LPWSTR                  lpwsServerName,
    OUT MIB_SERVER_HANDLE *     phMIBServer
)
{
    //
    // Bind with the server
    //

    return( DimRPCBind( lpwsServerName, phMIBServer ) );

}

//**
//
// Call:        MprAdminMIBServerDisconnect
//
// Returns:     none.
//
// Description: This is the DLL entrypoint for MIBServerDisconnect
//
VOID
MprAdminMIBServerDisconnect(
    IN MIB_SERVER_HANDLE    hMIBServer
)
{
    RpcBindingFree( (handle_t *)&hMIBServer );
}

//**
//
// Call:        MprAdminMIBBufferFree
//
// Returns:     none
//
// Description: This is the DLL entrypoint for MIBBufferFree
//
DWORD
MprAdminMIBBufferFree(
    IN PVOID        pBuffer
)
{
    if ( pBuffer == NULL )
    {
        return( ERROR_INVALID_PARAMETER );
    }

    MIDL_user_free( pBuffer );

    return( NO_ERROR );
}

//**
//
// Call:        MprAdminMIBEntryCreate
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RMIBEntryCreate
//
// Description: This is the DLL entrypoint for MIBEntryCreate
//
DWORD APIENTRY
MprAdminMIBEntryCreate(
    IN      MIB_SERVER_HANDLE       hMIBServer,
    IN      DWORD                   dwPid,
    IN      DWORD                   dwRoutingPid,
    IN      LPVOID                  lpEntry,
    IN      DWORD                   dwEntrySize
)
{
    DWORD                       dwRetCode;
    DIM_MIB_ENTRY_CONTAINER     InfoStruct;

    //
    // Make sure that all pointers passed in are valid
    //

    if ( lpEntry == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        InfoStruct.dwMibInEntrySize = dwEntrySize;

        InfoStruct.pMibInEntry  = lpEntry;

        InfoStruct.dwMibOutEntrySize = 0;
        InfoStruct.pMibOutEntry = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMIBEntryCreate(hMIBServer,
                                    dwPid,
                                    dwRoutingPid,
                                    &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminMIBEntryDelete
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RMIBEntryDelete
//
// Description: This is the DLL entrypoint for MIBEntryDelete
//
DWORD APIENTRY
MprAdminMIBEntryDelete(
    IN      MIB_SERVER_HANDLE       hMIBServer,
    IN      DWORD                   dwPid,
    IN      DWORD                   dwRoutingPid,
    IN      LPVOID                  lpEntry,
    IN      DWORD                   dwEntrySize
)
{
    DWORD                       dwRetCode;
    DIM_MIB_ENTRY_CONTAINER     InfoStruct;

    //
    // Make sure that all pointers passed in are valid
    //

    if ( lpEntry == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        InfoStruct.dwMibInEntrySize = dwEntrySize;

        InfoStruct.pMibInEntry = lpEntry;

        InfoStruct.dwMibOutEntrySize = 0;
        InfoStruct.pMibOutEntry      = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMIBEntryDelete(hMIBServer,
                                    dwPid,
                                    dwRoutingPid,
                                    &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminMIBEntrySet
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RMIBEntrySet
//
// Description: This is the DLL entrypoint for MIBEntrySet
//
DWORD APIENTRY
MprAdminMIBEntrySet(
    IN      MIB_SERVER_HANDLE       hMIBServer,
    IN      DWORD                   dwPid,
    IN      DWORD                   dwRoutingPid,
    IN      LPVOID                  lpEntry,
    IN      DWORD                   dwEntrySize
)
{
    DWORD                       dwRetCode;
    DIM_MIB_ENTRY_CONTAINER     InfoStruct;

    //
    // Make sure that all pointers passed in are valid
    //

    if ( lpEntry == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        InfoStruct.dwMibInEntrySize = dwEntrySize;

        InfoStruct.pMibInEntry = lpEntry;

        InfoStruct.dwMibOutEntrySize = 0;
        InfoStruct.pMibOutEntry      = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMIBEntrySet(   hMIBServer,
                                    dwPid,
                                    dwRoutingPid,
                                    &InfoStruct );

    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminMIBEntryGet
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RMIBEntryGet
//
// Description: This is the DLL entrypoint for MIBEntryGet
//
DWORD APIENTRY
MprAdminMIBEntryGet(
    IN      MIB_SERVER_HANDLE       hMIBServer,
    IN      DWORD                   dwPid,
    IN      DWORD                   dwRoutingPid,
    IN      LPVOID                  lpInEntry,
    IN      DWORD                   dwInEntrySize,
    OUT     LPVOID *                lplpOutEntry,
    OUT     LPDWORD                 lpdwOutEntrySize
)
{
    DWORD                       dwRetCode;
    DIM_MIB_ENTRY_CONTAINER     InfoStruct;

    //
    // Make sure that all pointers passed in are valid
    //

    if ( lpInEntry == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        *lplpOutEntry     = NULL;
        *lpdwOutEntrySize = 0;

        InfoStruct.pMibInEntry = lpInEntry;
        InfoStruct.dwMibInEntrySize = dwInEntrySize;

        InfoStruct.dwMibOutEntrySize = 0;
        InfoStruct.pMibOutEntry      = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMIBEntryGet(hMIBServer,
                                 dwPid,
                                 dwRoutingPid,
                                 &InfoStruct );

        if ( InfoStruct.pMibOutEntry != NULL )
        {
            *lplpOutEntry     = (LPVOID)(InfoStruct.pMibOutEntry);
            *lpdwOutEntrySize = InfoStruct.dwMibOutEntrySize;
        }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminMIBEntryGetFirst
//
// Returns:     NO_ERROR    - success
//              ERROR_INVALID_PARAMETER
//              non-zero return codes from RMIBEntryGetFirst
//
// Description: This is the DLL entrypoint for MIBEntryGetFirst
//
DWORD APIENTRY
MprAdminMIBEntryGetFirst(
    IN      MIB_SERVER_HANDLE       hMIBServer,
    IN      DWORD                   dwPid,
    IN      DWORD                   dwRoutingPid,
    IN      LPVOID                  lpInEntry,
    IN      DWORD                   dwInEntrySize,
    OUT     LPVOID *                lplpOutEntry,
    OUT     LPDWORD                 lpdwOutEntrySize
)
{
    DWORD                       dwRetCode;
    DIM_MIB_ENTRY_CONTAINER     InfoStruct;

    //
    // Make sure that all pointers passed in are valid
    //

    if ( lpInEntry == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    if (hMIBServer==NULL)
        return RPC_S_INVALID_BINDING;
        
    try
    {
        *lplpOutEntry     = NULL;
        *lpdwOutEntrySize = 0;

        InfoStruct.pMibInEntry = lpInEntry;
        InfoStruct.dwMibInEntrySize = dwInEntrySize;

        InfoStruct.dwMibOutEntrySize = 0;
        InfoStruct.pMibOutEntry      = NULL;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMIBEntryGetFirst(
                                hMIBServer,
                                dwPid,
                                dwRoutingPid,
                                &InfoStruct );

        if ( InfoStruct.pMibOutEntry != NULL )
        {
            *lplpOutEntry     = (LPVOID)(InfoStruct.pMibOutEntry);
            *lpdwOutEntrySize = InfoStruct.dwMibOutEntrySize;
        }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminMIBEntryGetNext
//
// Returns:     NO_ERROR    - success
//              non-zero return codes from RMIBEntryGetNext
//
// Description: This is the DLL entrypoint for MIBEntryGetNext
//
DWORD APIENTRY
MprAdminMIBEntryGetNext(
    IN      MIB_SERVER_HANDLE       hMIBServer,
    IN      DWORD                   dwPid,
    IN      DWORD                   dwRoutingPid,
    IN      LPVOID                  lpInEntry,
    IN      DWORD                   dwInEntrySize,
    OUT     LPVOID *                lplpOutEntry,
    OUT     LPDWORD                 lpdwOutEntrySize
)
{
    DWORD                       dwRetCode;
    DIM_MIB_ENTRY_CONTAINER     InfoStruct;

    //
    // Make sure that all pointers passed in are valid
    //

    if ( lpInEntry == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        *lplpOutEntry     = NULL;
        *lpdwOutEntrySize = 0;

        InfoStruct.pMibInEntry = lpInEntry;
        InfoStruct.dwMibInEntrySize = dwInEntrySize;

        InfoStruct.pMibOutEntry      = NULL;
        InfoStruct.dwMibOutEntrySize = 0;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMIBEntryGetNext(
                                hMIBServer,
                                dwPid,
                                dwRoutingPid,
                                &InfoStruct );

        if ( InfoStruct.pMibOutEntry != NULL )
        {
            *lplpOutEntry     = (LPVOID)(InfoStruct.pMibOutEntry);
            *lpdwOutEntrySize = InfoStruct.dwMibOutEntrySize;
        }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminMIBGetTrapInfo
//
// Returns:     NO_ERROR    - success
//              non-zero return codes from RMIBGetTrapInfo
//
// Description: This is the DLL entrypoint for MIBGetTrapInfo
//
DWORD APIENTRY
MprAdminMIBGetTrapInfo(
    IN      MIB_SERVER_HANDLE       hMIBServer,
    IN      DWORD                   dwPid,
    IN      DWORD                   dwRoutingPid,
    IN      LPVOID                  lpInData,
    IN      DWORD                   dwInDataSize,
    OUT     LPVOID*                 lplpOutData,
    IN OUT  LPDWORD                 lpdwOutDataSize
)
{
    DWORD                       dwRetCode;
    DIM_MIB_ENTRY_CONTAINER     InfoStruct;

    //
    // Make sure that all pointers passed in are valid
    //

    if ( lpInData == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    try
    {
        *lplpOutData     = NULL;
        *lpdwOutDataSize = 0;

        InfoStruct.pMibInEntry = lpInData;
        InfoStruct.dwMibInEntrySize = dwInDataSize;

        InfoStruct.pMibOutEntry      = NULL;
        InfoStruct.dwMibOutEntrySize = 0;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMIBGetTrapInfo(
                                hMIBServer,
                                dwPid,
                                dwRoutingPid,
                                &InfoStruct );

        if ( InfoStruct.pMibOutEntry != NULL )
        {
            *lplpOutData     = (LPVOID)(InfoStruct.pMibOutEntry);
            *lpdwOutDataSize = InfoStruct.dwMibOutEntrySize;
        }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    return( dwRetCode );
}

//**
//
// Call:        MprAdminMIBSetTrapInfo
//
// Returns:     NO_ERROR    - success
//              non-zero return codes from RMIBSetTrapInfo
//
// Description: This is the DLL entrypoint for MIBSetTrapInfo
//
DWORD APIENTRY
MprAdminMIBSetTrapInfo(
    IN      DWORD                   dwPid,
    IN      DWORD                   dwRoutingPid,
    IN      HANDLE                  hEvent,
    IN      LPVOID                  lpInData,
    IN      DWORD                   dwInDataSize,
    OUT     LPVOID*                 lplpOutData,
    IN OUT  LPDWORD                 lpdwOutDataSize
)
{
    DWORD                       dwRetCode;
    DIM_MIB_ENTRY_CONTAINER     InfoStruct;
    MIB_SERVER_HANDLE           hMIBServer;
    DWORD                       dwCurrentProcessId = GetCurrentProcessId();

    dwRetCode = MprAdminMIBServerConnect( NULL, &hMIBServer );

    if ( dwRetCode != NO_ERROR )
    {
        return( dwRetCode );
    }

    if ( lpInData == NULL )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    //
    // Make sure that all pointers passed in are valid
    //

    try
    {
        *lplpOutData     = NULL;
        *lpdwOutDataSize = 0;

        InfoStruct.pMibInEntry = lpInData;
        InfoStruct.dwMibInEntrySize = dwInDataSize;

        InfoStruct.pMibOutEntry      = NULL;
        InfoStruct.dwMibOutEntrySize = 0;
    }
    except( EXCEPTION_EXECUTE_HANDLER )
    {
	    return( ERROR_INVALID_PARAMETER );
    }

    RpcTryExcept
    {
        dwRetCode = RMIBSetTrapInfo(
                                hMIBServer,
                                dwPid,
                                dwRoutingPid,
                                (ULONG_PTR) hEvent,
                                dwCurrentProcessId,
                                &InfoStruct );

        if ( InfoStruct.pMibOutEntry != NULL )
        {
            *lplpOutData     = (LPVOID)(InfoStruct.pMibOutEntry);
            *lpdwOutDataSize = InfoStruct.dwMibOutEntrySize;
        }
    }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
    {
        dwRetCode = RpcExceptionCode();
    }
    RpcEndExcept

    MprAdminMIBServerDisconnect( hMIBServer );

    return( dwRetCode );
}

DWORD APIENTRY
MprAdminConnectionEnum(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      DWORD                   dwLevel,
    OUT     LPBYTE *                lplpbBuffer,        // RAS_CONNECTION_0
    IN      DWORD                   dwPrefMaxLen,
    OUT     LPDWORD                 lpdwEntriesRead,
    OUT     LPDWORD                 lpdwTotalEntries,
    IN      LPDWORD                 lpdwResumeHandle    OPTIONAL
)
{
    if (!hRasServer)
        return RPC_S_INVALID_BINDING;
    if (!lplpbBuffer || !lpdwEntriesRead || !lpdwTotalEntries)
    {
        return ERROR_INVALID_PARAMETER;
    }
    if (dwLevel>=3)
        return ERROR_INVALID_LEVEL;
        
    return( RasAdminConnectionEnum( hRasServer, dwLevel, lplpbBuffer,
                                    dwPrefMaxLen, lpdwEntriesRead,
                                    lpdwTotalEntries, lpdwResumeHandle ) );
}

DWORD APIENTRY
MprAdminPortEnum(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      DWORD                   dwLevel,
    IN      HANDLE                  hRasConnection,
    OUT     LPBYTE *                lplpbBuffer,        // RAS_PORT_0
    IN      DWORD                   dwPrefMaxLen,
    OUT     LPDWORD                 lpdwEntriesRead,
    OUT     LPDWORD                 lpdwTotalEntries,
    IN      LPDWORD                 lpdwResumeHandle    OPTIONAL
)
{
    if (dwLevel!=0)
        return ERROR_NOT_SUPPORTED;
        
    return( RasAdminPortEnum( hRasServer, dwLevel, hRasConnection, lplpbBuffer,
                              dwPrefMaxLen, lpdwEntriesRead, lpdwTotalEntries,
                              lpdwResumeHandle ) );
}

DWORD APIENTRY
MprAdminConnectionGetInfo(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      DWORD                   dwLevel,
    IN      HANDLE                  hRasConnection,
    OUT     LPBYTE *                lplpbBuffer
)
{
    return( RasAdminConnectionGetInfo( hRasServer, dwLevel, hRasConnection,
                                       lplpbBuffer ) );
}

DWORD APIENTRY
MprAdminPortGetInfo(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      DWORD                   dwLevel,
    IN      HANDLE                  hPort,
    OUT     LPBYTE *                lplpbBuffer
)
{
    return( RasAdminPortGetInfo( hRasServer, dwLevel, hPort, lplpbBuffer ) );
}

DWORD APIENTRY
MprAdminConnectionClearStats(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      HANDLE                  hRasConnection
)
{
    return( RasAdminConnectionClearStats( hRasServer, hRasConnection ) );
}

DWORD APIENTRY
MprAdminPortClearStats(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      HANDLE                  hPort
)
{
    return( RasAdminPortClearStats( hRasServer, hPort ) );
}

DWORD APIENTRY
MprAdminPortReset(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      HANDLE                  hPort
)
{
    return( RasAdminPortReset( hRasServer, hPort ) );
}

DWORD APIENTRY
MprAdminPortDisconnect(
    IN      RAS_SERVER_HANDLE       hRasServer,
    IN      HANDLE                  hPort
)
{
    return( RasAdminPortDisconnect( hRasServer, hPort ) );
}

DWORD APIENTRY
MprAdminInterfaceSetCredentials(
    IN      LPWSTR                  lpwsServer              OPTIONAL,
    IN      LPWSTR                  lpwsInterfaceName,
    IN      LPWSTR                  lpwsUserName            OPTIONAL,
    IN      LPWSTR                  lpwsDomainName          OPTIONAL,
    IN      LPWSTR                  lpwsPassword            OPTIONAL
)
{
    return 
        MprAdminInterfaceSetCredentialsInternal(
            lpwsServer,
            lpwsInterfaceName,
            lpwsUserName,
            lpwsDomainName,
            lpwsPassword);
}

DWORD APIENTRY
MprAdminInterfaceGetCredentials(
    IN      LPWSTR                  lpwsServer              OPTIONAL,
    IN      LPWSTR                  lpwsInterfaceName,
    IN      LPWSTR                  lpwsUserName            OPTIONAL,
    IN      LPWSTR                  lpwsPassword            OPTIONAL,
    IN      LPWSTR                  lpwsDomainName          OPTIONAL
)
{
    DWORD dwErr;

    dwErr = 
        MprAdminInterfaceGetCredentialsInternal(
            lpwsServer,
            lpwsInterfaceName,
            lpwsUserName,
            NULL,
            lpwsDomainName);

    if (dwErr == NO_ERROR)
    {
        if (lpwsPassword != NULL)
        {
            wcscpy(lpwsPassword, L"****************");
        }
    }

    return dwErr;
}

DWORD APIENTRY
MprAdminConnectionRemoveQuarantine(
    IN      HANDLE          hRasServer,    
    IN      HANDLE          hRasConnection,
    IN      BOOL            fIsIpAddress)
{
    DWORD dwErr;

    dwErr = RRasAdminConnectionRemoveQuarantine(
                            hRasServer,
                            PtrToUlong(hRasConnection),
                            fIsIpAddress);

    return dwErr;                            
}