windows-nt-4.0/private/rpc/ndrlib/ccontext.cxx

/* --------------------------------------------------------------------

                      Microsoft OS/2 LAN Manager
		   Copyright(c) Microsoft Corp., 1991

-------------------------------------------------------------------- */
/* --------------------------------------------------------------------

Description :

Provides RPC client side stub context management

History :

stevez	01-15-91	First bits into the bucket.

-------------------------------------------------------------------- */

#ifdef NTENV

extern "C"
{
#include <sysinc.h>
}

#else // NTENV

#include <sysinc.h>

#endif // NTENV

#include <rpc.h>
#include <rpcdcep.h>
#include <rpcndr.h>
#include <util.hxx>
#include <osfpcket.hxx>

#ifdef NTENV
#include <memory.h>
#endif // NTENV

#ifdef WIN
#define memset _fmemset
#define memcpy _fmemcpy
#define memcmp _fmemcmp
#endif // WIN

// The NDR format of a context is a (GUID, long) instead of a pointer
// in the server address space due history.  Anyway, we just save this
// cookie, which is sent on the and mapped to and from a pointer
// on the server side.

#define CONTEXT_MAGIC_VALUE 0xFEDCBA98

typedef struct _WIRE_CONTEXT
{
    unsigned long ContextType;
    UUID ContextUuid;
} WIRE_CONTEXT;

typedef struct _CCONTEXT {

    RPC_BINDING_HANDLE hRPC;	// binding handle assoicated with context

    unsigned long MagicValue;
    WIRE_CONTEXT NDR;

} CCONTEXT, *PCCONTEXT;

static unsigned char NilContext[20];


RPC_BINDING_HANDLE RPC_ENTRY
NDRCContextBinding (
    IN NDR_CCONTEXT CContext
    )
/*++

Routine Description:

    Given a client context handle, we need to extract the binding from it.
    If an addressing exception occurs, we need to return invalid handle
    rather than GP-fault.

Arguments:

    CContext - Supplies the client context handle.

Return Value:

    The binding handle associated with the supplied client context handle
    will be returned.  If the client context handle is invalid, then we
    raise the RPC_X_SS_CONTEXT_MISMATCH exception.

--*/
{
#ifdef NTENV

    RpcTryExcept
        {
        if ( ((CCONTEXT PAPI *) CContext)->MagicValue != CONTEXT_MAGIC_VALUE )
            {
            RpcRaiseException(RPC_X_SS_CONTEXT_MISMATCH);
            }
        }
    RpcExcept(   ( RpcExceptionCode() == STATUS_ACCESS_VIOLATION )
              || ( RpcExceptionCode() == STATUS_DATATYPE_MISALIGNMENT ) )
        {
        RpcRaiseException(RPC_X_SS_CONTEXT_MISMATCH);
        }
    RpcEndExcept

#else // NTENV

    if (   ( CContext == 0 )
        || ( ((CCONTEXT PAPI *) CContext)->MagicValue != CONTEXT_MAGIC_VALUE ) )
        {
        RpcRaiseException(RPC_X_SS_CONTEXT_MISMATCH);
        }

#endif // NTENV

    return(((CCONTEXT PAPI *) CContext)->hRPC);
}


void RPC_ENTRY
NDRCContextMarshall (		// copy a context to a buffer

IN  NDR_CCONTEXT hCC,		// context to marshell
OUT void PAPI *pBuff		// buffer to marshell to

  // Copy the interal representation of a context into a buffer
) //-----------------------------------------------------------------------//
{
#define hCContext ((CCONTEXT PAPI *) hCC)  // cast opeqe pointer to internal

    if (!hCContext)
        memset(pBuff, 0, cbNDRContext);
    else
        {

        // Check the magic value to see if this is a legit context
        
        RpcTryExcept
            {
            if ( ((CCONTEXT PAPI *) hCContext)->MagicValue != CONTEXT_MAGIC_VALUE )
                {
                RpcRaiseException(RPC_X_SS_CONTEXT_MISMATCH);
                }
            }
        RpcExcept(1)
            {
            RpcRaiseException(RPC_X_SS_CONTEXT_MISMATCH);
            }
        RpcEndExcept
        
     	memcpy(pBuff, &hCContext->NDR, sizeof(hCContext->NDR));
        }

#undef hCContext
}


static void
ByteSwapWireContext(
    IN WIRE_CONTEXT PAPI * WireContext,
    IN unsigned long PAPI * DataRepresentation
    )
/*++

Routine Description:

    If necessary, the wire context will be byte swapped in place.

Arguments:

    WireContext - Supplies the wire context be byte swapped and returns the
        resulting byte swapped context.

    DataRepresentation - Supplies the data representation of the supplied wire
        context.

--*/
{
    if ( (*DataRepresentation & NDR_LITTLE_ENDIAN) 
                      != NDR_LOCAL_ENDIAN ) 
        {
        ByteSwapLong(WireContext->ContextType);
        ByteSwapLong(WireContext->ContextUuid.Data1);
        ByteSwapShort(WireContext->ContextUuid.Data2);
        ByteSwapShort(WireContext->ContextUuid.Data3);
        }
}

void RPC_ENTRY
NDRCContextUnmarshall (		// process returned context

OUT NDR_CCONTEXT PAPI *phCContext,// stub context to update
IN  RPC_BINDING_HANDLE hRPC,		// binding handle to associate with
IN  void PAPI *pBuff,		// pointer to NDR wire format
IN  unsigned long DataRepresentation	// pointer to NDR data rep

  // Update the users context handle from the servers NDR wire format.
) //-----------------------------------------------------------------------//
{
    PCCONTEXT hCC = (PCCONTEXT) ((long) *phCContext);

    // destory this context if the server returned none

    ByteSwapWireContext((WIRE_CONTEXT PAPI *) pBuff,
            (unsigned long PAPI *) &DataRepresentation);

    ASSERT( !RpcpCheckHeap() );

    if (memcmp(pBuff, NilContext, cbNDRContext) == 0)
	{
	if (hCC)
	    {
	    if (hCC->hRPC)
		RpcBindingFree(&(hCC->hRPC));	// discard duplicated binding

            hCC->MagicValue = 0;
	    I_RpcFree(hCC);
	    }

	*phCContext = Nil;
	return;
	}

	PCCONTEXT hCCtemp = 0;

    if (! hCC)			// allocate new if none existed
        {
        hCCtemp = (PCCONTEXT) I_RpcAllocate(sizeof(CCONTEXT));

        if (hCCtemp == 0)
           {
           RpcRaiseException(RPC_S_OUT_OF_MEMORY);
           }

        hCCtemp->MagicValue = CONTEXT_MAGIC_VALUE;
        }
    else if (memcmp(&hCC->NDR, pBuff, sizeof(hCC->NDR)) == 0)
        {
        // the returned context is the same as the app's context.

        return;
        }


    RPC_BINDING_HANDLE hBindtemp ;

    if( I_RpcBindingCopy(hRPC, &hBindtemp) != RPC_S_OK )
        {
        ASSERT( !RpcpCheckHeap() );
        I_RpcFree( hCCtemp );
        RpcRaiseException(RPC_S_OUT_OF_MEMORY);
        }

    if ( hCCtemp )
        hCC = hCCtemp;
    else
        RpcBindingFree(&(hCC->hRPC));

    memcpy(&hCC->NDR, pBuff, sizeof(hCC->NDR));
    hCC->hRPC = hBindtemp;

    ASSERT( !RpcpCheckHeap() );

    *phCContext = (NDR_CCONTEXT)hCC;
}


void RPC_ENTRY
RpcSsDestroyClientContext (
    IN OUT void PAPI * PAPI * ContextHandle
    )
/*++

Routine Description:

    A client application will use this routine to destroy a context handle
    which it no longer needs.  This will work without having to contact the
    server.

Arguments:

    ContextHandle - Supplies the context handle to be destroyed.  It will
        be set to zero before this routine returns.

Exceptions:

    If the context handle is invalid, then the RPC_X_SS_CONTEXT_MISMATCH
    exception will be raised.

--*/
{
    RPC_BINDING_HANDLE BindingHandle;
    RPC_STATUS RpcStatus;

    BindingHandle = NDRCContextBinding(*ContextHandle);

    RpcStatus = RpcBindingFree(&BindingHandle);
    // ASSERT( RpcStatus == RPC_S_OK ); 

    I_RpcFree(*ContextHandle);
    *ContextHandle = 0;
}