You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
866 lines
25 KiB
866 lines
25 KiB
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
Copyright (c) 1993 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
mrshlp.c
|
|
|
|
Abstract :
|
|
|
|
This file contains the routines for marshalling an array's or a structure's
|
|
embedded pointers and for computing conformance and variance counts and
|
|
union switch values.
|
|
|
|
Author :
|
|
|
|
David Kays dkays September 1993.
|
|
|
|
Revision History :
|
|
|
|
---------------------------------------------------------------------*/
|
|
|
|
#include "ndrp.h"
|
|
#include "attack.h"
|
|
#include "interp2.h"
|
|
#include "mulsyntx.h"
|
|
#include "asyncu.h"
|
|
#include "pointerq.h"
|
|
|
|
|
|
PFORMAT_STRING
|
|
NdrpEmbeddedPointerMarshall(
|
|
PMIDL_STUB_MESSAGE pStubMsg,
|
|
uchar * pMemory,
|
|
PFORMAT_STRING pFormat )
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
Marshalls an array's or a structure's embedded pointers.
|
|
|
|
Arguments :
|
|
|
|
pStubMsg - Pointer to the stub message.
|
|
pMemory - Pointer to the structure or array whose embedded pointers
|
|
are being marshalled.
|
|
pFormat - The format string pointer layout. Should point to the
|
|
pointer layout's beginning FC_PP character upon entry.
|
|
|
|
Return :
|
|
|
|
Format string pointer after the pointer layout.
|
|
|
|
--*/
|
|
{
|
|
uchar ** ppMemPtr;
|
|
uchar * pBufPtr;
|
|
uchar * pBufferMark;
|
|
uchar * pMemorySave;
|
|
ULONG_PTR MaxCountSave;
|
|
long OffsetSave;
|
|
|
|
MaxCountSave = pStubMsg->MaxCount;
|
|
OffsetSave = pStubMsg->Offset;
|
|
|
|
POINTER_BUFFER_SWAP_CONTEXT SwapContext(pStubMsg);
|
|
|
|
pMemorySave = pStubMsg->Memory;
|
|
|
|
// This is where the embedding structure or array begins in the buffer.
|
|
pBufferMark = pStubMsg->BufferMark;
|
|
|
|
//
|
|
// The Memory field in the stub message keeps track of the pointer to
|
|
// the current embedding structure or array. This is needed to handle
|
|
// size/length pointers, so that we can get a pointer to the current
|
|
// embedding struct when computing conformance and variance.
|
|
//
|
|
pStubMsg->Memory = pMemory;
|
|
|
|
// Skip FC_PP and FC_PAD.
|
|
pFormat += 2;
|
|
|
|
for (;;)
|
|
{
|
|
|
|
if ( *pFormat == FC_END )
|
|
{
|
|
pStubMsg->Memory = pMemorySave;
|
|
|
|
return pFormat;
|
|
}
|
|
|
|
//
|
|
// Check for FC_FIXED_REPEAT and FC_VARIABLE_REPEAT.
|
|
//
|
|
if ( *pFormat != FC_NO_REPEAT )
|
|
{
|
|
pStubMsg->MaxCount = MaxCountSave;
|
|
pStubMsg->Offset = OffsetSave;
|
|
|
|
pStubMsg->BufferMark = pBufferMark;
|
|
|
|
pFormat = NdrpEmbeddedRepeatPointerMarshall( pStubMsg,
|
|
pMemory,
|
|
pFormat );
|
|
// Continue to the next pointer.
|
|
continue;
|
|
}
|
|
|
|
// Compute the pointer to the pointer to marshall.
|
|
ppMemPtr = (uchar **)(pMemory + *((signed short *)(pFormat + 2)));
|
|
|
|
//
|
|
// Compute the location in the buffer where the pointer's value will be
|
|
// marshalled. Needed for full pointers.
|
|
//
|
|
pBufPtr = pBufferMark + *((signed short *)(pFormat + 4));
|
|
|
|
// Increment to the pointer description.
|
|
pFormat += 6;
|
|
|
|
//
|
|
// Now marshall the pointer.
|
|
//
|
|
NdrpPointerMarshall( pStubMsg,
|
|
pBufPtr,
|
|
*ppMemPtr,
|
|
pFormat );
|
|
|
|
// Increment to the next pointer description.
|
|
pFormat += 4;
|
|
|
|
} // for
|
|
}
|
|
|
|
|
|
PFORMAT_STRING
|
|
NdrpEmbeddedRepeatPointerMarshall(
|
|
PMIDL_STUB_MESSAGE pStubMsg,
|
|
uchar * pMemory,
|
|
PFORMAT_STRING pFormat )
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
Marshalls an array's embedded pointers.
|
|
|
|
Arguments :
|
|
|
|
pStubMsg - Pointer to the stub message.
|
|
pMemory - Array whose embedded pointers are being marshalled.
|
|
pFormat - Pointer layout format string description.
|
|
|
|
Return :
|
|
|
|
Format string pointer after the pointer layout.
|
|
|
|
--*/
|
|
{
|
|
uchar ** ppMemPtr;
|
|
uchar * pBufPtr;
|
|
PFORMAT_STRING pFormatSave;
|
|
uchar * pMemorySave;
|
|
uchar * pBufferMark;
|
|
ulong RepeatCount, RepeatIncrement, Pointers, PointersSave;
|
|
|
|
pMemorySave = pStubMsg->Memory;
|
|
|
|
//
|
|
// This is where the current embedding structure or array begins in
|
|
// the buffer.
|
|
//
|
|
pBufferMark = pStubMsg->BufferMark;
|
|
|
|
// Get the number of shipped elements in the array.
|
|
switch ( *pFormat )
|
|
{
|
|
case FC_FIXED_REPEAT :
|
|
pFormat += 2;
|
|
|
|
RepeatCount = *((ushort *)pFormat);
|
|
|
|
break;
|
|
|
|
case FC_VARIABLE_REPEAT :
|
|
RepeatCount = (ulong)pStubMsg->MaxCount;
|
|
|
|
//
|
|
// Check if this variable repeat instance also has a variable
|
|
// offset (this would be the case for a conformant varying array
|
|
// of pointers). If so then increment the memory pointer by the
|
|
// increment size time the variance offset.
|
|
//
|
|
if ( pFormat[1] == FC_VARIABLE_OFFSET )
|
|
pMemory += *((ushort *)(pFormat + 2)) * pStubMsg->Offset;
|
|
|
|
// else pFormat[1] == FC_FIXED_OFFSET - do nothing
|
|
|
|
break;
|
|
|
|
default :
|
|
NDR_ASSERT(0,"NdrpEmbeddedRepeatPointerMarshall : bad format char");
|
|
RpcRaiseException( RPC_S_INTERNAL_ERROR );
|
|
return 0;
|
|
}
|
|
|
|
// Increment format string to increment field.
|
|
pFormat += 2;
|
|
|
|
// Get the increment amount between successive pointers.
|
|
// This is actually an increment over the array element.
|
|
RepeatIncrement = *((ushort * &)pFormat)++;
|
|
|
|
//
|
|
// Add the offset to the beginning of this array to the Memory
|
|
// pointer. This is the offset from the current embedding structure
|
|
// or array to the array whose pointers we're marshalling.
|
|
//
|
|
pStubMsg->Memory += *((ushort * &)pFormat)++;
|
|
|
|
// Get the number of pointers in this repeat instance.
|
|
PointersSave = Pointers = *((ushort * &)pFormat)++;
|
|
|
|
pFormatSave = pFormat;
|
|
|
|
//
|
|
// Loop over the number of shipped elements of the array.
|
|
//
|
|
for ( ; RepeatCount--;
|
|
pBufferMark += RepeatIncrement,
|
|
pMemory += RepeatIncrement,
|
|
pStubMsg->Memory += RepeatIncrement )
|
|
{
|
|
pFormat = pFormatSave;
|
|
Pointers = PointersSave;
|
|
|
|
//
|
|
// Loop over the number of pointer per array element (could be
|
|
// greater than one for an array of structures).
|
|
//
|
|
for ( ; Pointers--; )
|
|
{
|
|
ppMemPtr = (uchar **)(pMemory + *((signed short * &)pFormat)++);
|
|
|
|
pBufPtr = pBufferMark + *((signed short * &)pFormat)++;
|
|
|
|
NdrpPointerMarshall( pStubMsg,
|
|
pBufPtr,
|
|
*ppMemPtr,
|
|
pFormat );
|
|
|
|
// Increment to the next pointer's offset_in_memory.
|
|
pFormat += 4;
|
|
}
|
|
}
|
|
|
|
pStubMsg->Memory = pMemorySave;
|
|
|
|
// Return the format string pointer past the pointer descriptions.
|
|
return pFormatSave + PointersSave * 8;
|
|
}
|
|
|
|
|
|
ULONG_PTR
|
|
NdrpComputeConformance (
|
|
PMIDL_STUB_MESSAGE pStubMsg,
|
|
uchar * pMemory,
|
|
PFORMAT_STRING pFormat )
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
This routine computes the conformant size for an array or the switch_is
|
|
value for a union.
|
|
|
|
Arguments :
|
|
|
|
pStubMsg - Pointer to the stub message.
|
|
pMemory - Pointer to the array, string, or union whose size or switch_is
|
|
is being computed. This is ignored for top level parameters.
|
|
pFormat - Format string description of the array, string, or union.
|
|
|
|
Return :
|
|
|
|
The array or string size or the union switch_is.
|
|
|
|
Note:
|
|
Async splitting:
|
|
The only thing that the compiler should generate with the FC_SPLIT_* operations
|
|
should be top level conformance.
|
|
Expr evaluation routines and top level multi-dim sizing is not supported with
|
|
the async uuid split.
|
|
|
|
Note64:
|
|
On 64b platform this routine is can return 8 bytes of a iid_is pointer.
|
|
However, the MaxCount field does not need to keep it and it stays as a ulong.
|
|
|
|
|
|
--*/
|
|
{
|
|
void * pCount;
|
|
LONG_PTR Count;
|
|
|
|
unsigned char FormatCopy[4];
|
|
BOOL fAsyncSplit = FALSE;
|
|
|
|
static const uchar Increments[] =
|
|
{
|
|
4, // Conformant array.
|
|
4, // Conformant varying array.
|
|
0, 0, // Fixed arrays - unused.
|
|
0, 0, // Varying arrays - unused.
|
|
4, // Complex array.
|
|
|
|
2, // Conformant char string.
|
|
2, // Conformant byte string.
|
|
4, // Conformant stringable struct.
|
|
2, // Conformant wide char string.
|
|
|
|
0, 0, 0, 0, // Non-conformant strings - unused.
|
|
|
|
0, // Encapsulated union - unused.
|
|
2, // Non-encapsulated union.
|
|
2, // Byte count pointer.
|
|
0, 0, // Xmit/Rep as - unused.
|
|
2 // Interface pointer.
|
|
};
|
|
|
|
//
|
|
// Advance the format string to the size_is, switch_is, iid_is, or
|
|
// byte count description.
|
|
//
|
|
pFormat += Increments[*pFormat - FC_CARRAY];
|
|
|
|
pCount = 0;
|
|
|
|
//
|
|
// First check if this is a callback.
|
|
//
|
|
if ( pFormat[1] == FC_CALLBACK )
|
|
{
|
|
uchar * pOldStackTop;
|
|
ushort Index;
|
|
|
|
// Index into expression callback routines table.
|
|
Index = *((ushort *)(pFormat + 2));
|
|
|
|
NDR_ASSERT(pStubMsg->StubDesc->apfnExprEval != 0,
|
|
"NdrpComputeConformance : no expr eval routines");
|
|
NDR_ASSERT(pStubMsg->StubDesc->apfnExprEval[Index] != 0,
|
|
"NdrpComputeConformance : bad expr eval routine index");
|
|
|
|
pOldStackTop = pStubMsg->StackTop;
|
|
|
|
//
|
|
// The callback routine uses the StackTop field of the stub message
|
|
// to base it's offsets from. So if this is a complex attribute for
|
|
// an embedded field of a structure then set StackTop equal to the
|
|
// pointer to the structure.
|
|
//
|
|
if ( (*pFormat & 0xf0) != FC_TOP_LEVEL_CONFORMANCE )
|
|
{
|
|
if ( (*pFormat & 0xf0) == FC_POINTER_CONFORMANCE )
|
|
pMemory = pStubMsg->Memory;
|
|
pStubMsg->StackTop = pMemory;
|
|
}
|
|
|
|
//
|
|
// This call puts the result in pStubMsg->MaxCount.
|
|
//
|
|
(*pStubMsg->StubDesc->apfnExprEval[Index])( pStubMsg );
|
|
|
|
pStubMsg->StackTop = pOldStackTop;
|
|
|
|
return pStubMsg->MaxCount;
|
|
}
|
|
|
|
if ( (*pFormat & 0xf0) == FC_NORMAL_CONFORMANCE )
|
|
{
|
|
// Get the address where the conformance variable is in the struct.
|
|
pCount = pMemory + *((signed short *)(pFormat + 2));
|
|
goto ComputeConformantGetCount;
|
|
}
|
|
|
|
// See if this is an async split
|
|
|
|
if ( pFormat[1] & 0x20 )
|
|
{
|
|
fAsyncSplit = TRUE;
|
|
RpcpMemoryCopy( & FormatCopy[0], pFormat, 4 );
|
|
pFormat = (PFORMAT_STRING) & FormatCopy[0];
|
|
|
|
// Remove the async marker
|
|
FormatCopy[1] = pFormat[1] & (unsigned char)~0x20;
|
|
}
|
|
|
|
//
|
|
// Get a pointer to the conformance describing variable.
|
|
//
|
|
if ( (*pFormat & 0xf0) == FC_TOP_LEVEL_CONFORMANCE )
|
|
{
|
|
//
|
|
// Top level conformance. For /Os stubs, the stubs put the max
|
|
// count in the stub message. For /Oi stubs, we get the max count
|
|
// via an offset from the stack top.
|
|
//
|
|
if ( pStubMsg->StackTop )
|
|
{
|
|
if ( fAsyncSplit )
|
|
{
|
|
PNDR_DCOM_ASYNC_MESSAGE pAsyncMsg;
|
|
|
|
pAsyncMsg = (PNDR_DCOM_ASYNC_MESSAGE) pStubMsg->pAsyncMsg;
|
|
|
|
pCount = pAsyncMsg->BeginStack + *((ushort *)(pFormat + 2));
|
|
}
|
|
else
|
|
pCount = pStubMsg->StackTop + *((ushort *)(pFormat + 2));
|
|
goto ComputeConformantGetCount;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If this is top level conformance with /Os then we don't have
|
|
// to do anything, the proper conformance count is placed in the
|
|
// stub message inline in the stubs.
|
|
//
|
|
return pStubMsg->MaxCount;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we're computing the size of an embedded sized pointer then we
|
|
// use the memory pointer in the stub message, which points to the
|
|
// beginning of the embedding structure.
|
|
//
|
|
if ( (*pFormat & 0xf0) == FC_POINTER_CONFORMANCE )
|
|
{
|
|
pMemory = pStubMsg->Memory;
|
|
pCount = pMemory + *((signed short *)(pFormat + 2));
|
|
goto ComputeConformantGetCount;
|
|
}
|
|
|
|
//
|
|
// Check for constant size/switch.
|
|
//
|
|
if ( (*pFormat & 0xf0) == FC_CONSTANT_CONFORMANCE )
|
|
{
|
|
//
|
|
// The size/switch is contained in the lower three bytes of the
|
|
// long currently pointed to by pFormat.
|
|
//
|
|
Count = (LONG_PTR) ((ulong)pFormat[1] << 16);
|
|
Count |= (LONG_PTR) *((ushort *)(pFormat + 2));
|
|
|
|
goto ComputeConformanceEnd;
|
|
}
|
|
|
|
//
|
|
// Check for conformance of a multidimensional array element in
|
|
// a -Os stub.
|
|
//
|
|
if ( (*pFormat & 0xf0) == FC_TOP_LEVEL_MULTID_CONFORMANCE )
|
|
{
|
|
long Dimension;
|
|
|
|
if ( fAsyncSplit )
|
|
RpcRaiseException( RPC_X_WRONG_STUB_VERSION );
|
|
|
|
//
|
|
// If pArrayInfo is non-null than we have a multi-D array. If it
|
|
// is null then we have multi-leveled sized pointers.
|
|
//
|
|
if ( pStubMsg->pArrayInfo )
|
|
{
|
|
Dimension = pStubMsg->pArrayInfo->Dimension;
|
|
pStubMsg->MaxCount = pStubMsg->pArrayInfo->MaxCountArray[Dimension];
|
|
}
|
|
else
|
|
{
|
|
Dimension = *((ushort *)(pFormat + 2));
|
|
pStubMsg->MaxCount = pStubMsg->SizePtrCountArray[Dimension];
|
|
}
|
|
|
|
return pStubMsg->MaxCount;
|
|
}
|
|
|
|
NDR_ASSERT(0, "NdrpComputeConformance:, Invalid Conformance type");
|
|
RpcRaiseException( RPC_S_INTERNAL_ERROR );
|
|
return 0; //bogus return
|
|
|
|
ComputeConformantGetCount:
|
|
|
|
//
|
|
// Must check now if there is a dereference op.
|
|
//
|
|
if ( pFormat[1] == FC_DEREFERENCE )
|
|
{
|
|
pCount = *(void **)pCount;
|
|
}
|
|
|
|
//
|
|
// Now get the conformance count.
|
|
//
|
|
switch ( *pFormat & 0x0f )
|
|
{
|
|
case FC_HYPER :
|
|
// iid_is on 64b platforms only.
|
|
Count = *((LONG_PTR *)pCount);
|
|
break;
|
|
|
|
case FC_ULONG :
|
|
Count = (LONG_PTR)*((ulong *)pCount);
|
|
break;
|
|
|
|
case FC_LONG :
|
|
Count = *((long *)pCount);
|
|
break;
|
|
|
|
case FC_ENUM16:
|
|
case FC_USHORT :
|
|
Count = (long) *((ushort *)pCount);
|
|
break;
|
|
|
|
case FC_SHORT :
|
|
Count = (long) *((short *)pCount);
|
|
break;
|
|
|
|
case FC_USMALL :
|
|
Count = (long) *((uchar *)pCount);
|
|
break;
|
|
|
|
case FC_SMALL :
|
|
Count = (long) *((char *)pCount);
|
|
break;
|
|
|
|
default :
|
|
NDR_ASSERT(0,"NdrpComputeConformance : bad count type");
|
|
RpcRaiseException( RPC_S_INTERNAL_ERROR );
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Check the operator.
|
|
//
|
|
switch ( pFormat[1] )
|
|
{
|
|
case FC_DIV_2 :
|
|
Count /= 2;
|
|
break;
|
|
case FC_MULT_2 :
|
|
Count *= 2;
|
|
break;
|
|
case FC_SUB_1 :
|
|
Count -= 1;
|
|
break;
|
|
case FC_ADD_1 :
|
|
Count += 1;
|
|
break;
|
|
default :
|
|
// OK
|
|
break;
|
|
}
|
|
|
|
ComputeConformanceEnd:
|
|
|
|
// Max count is not used for iid_is.
|
|
|
|
pStubMsg->MaxCount = (ulong) Count;
|
|
|
|
return (ULONG_PTR) Count;
|
|
}
|
|
|
|
|
|
void
|
|
NdrpComputeVariance (
|
|
PMIDL_STUB_MESSAGE pStubMsg,
|
|
uchar * pMemory,
|
|
PFORMAT_STRING pFormat )
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
Computes the variance (offset and actual count) for an array.
|
|
|
|
Arguments :
|
|
|
|
pStubMsg - Pointer to the stub message.
|
|
pMemory - Pointer to the array whose variance is being computed. This
|
|
is unused for a top level parameter.
|
|
pFormat - Format string description of the array.
|
|
|
|
Return :
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
void * pLength;
|
|
LONG_PTR Length;
|
|
|
|
unsigned char FormatCopy[4];
|
|
BOOL fAsyncSplit = FALSE;
|
|
|
|
uchar FcType = *pFormat;
|
|
|
|
//
|
|
// Advance the format string to the variance description.
|
|
//
|
|
|
|
static uchar Increments[] = { 8, // Conformant varying array.
|
|
0, 0, // Fixed arrays - unsed.
|
|
8, 12, // Varying array.
|
|
8 // Complex array.
|
|
};
|
|
|
|
pFormat += Increments[ FcType - FC_CVARRAY];
|
|
|
|
if (FcType == FC_CVARRAY || FcType == FC_BOGUS_ARRAY)
|
|
{
|
|
CORRELATION_DESC_INCREMENT( pFormat );
|
|
}
|
|
|
|
pLength = 0;
|
|
|
|
//
|
|
// First check if this is a callback.
|
|
//
|
|
if ( pFormat[1] == FC_CALLBACK )
|
|
{
|
|
ULONG_PTR OldMaxCount;
|
|
uchar * pOldStackTop;
|
|
ushort Index;
|
|
|
|
Index = *((ushort *)(pFormat + 2));
|
|
|
|
NDR_ASSERT(pStubMsg->StubDesc->apfnExprEval != 0,
|
|
"NdrpComputeConformance : no expr eval routines");
|
|
NDR_ASSERT(pStubMsg->StubDesc->apfnExprEval[Index] != 0,
|
|
"NdrpComputeConformance : bad expr eval routine index");
|
|
|
|
pOldStackTop = pStubMsg->StackTop;
|
|
|
|
// This gets trampled by the callback routine.
|
|
OldMaxCount = pStubMsg->MaxCount;
|
|
|
|
//
|
|
// The callback routine uses the StackTop field of the stub message
|
|
// to base it's offsets from. So if this is a complex attribute for
|
|
// an embedded field of a structure then set StackTop equal to the
|
|
// pointer to the structure.
|
|
//
|
|
if ( (*pFormat & 0xf0) != FC_TOP_LEVEL_CONFORMANCE )
|
|
{
|
|
if ( (*pFormat & 0xf0) == FC_POINTER_VARIANCE )
|
|
pMemory = pStubMsg->Memory;
|
|
pStubMsg->StackTop = pMemory;
|
|
}
|
|
|
|
//
|
|
// This puts the computed offset in pStubMsg->Offset and the length
|
|
// in pStubMsg->MaxCount.
|
|
//
|
|
(*pStubMsg->StubDesc->apfnExprEval[Index])( pStubMsg );
|
|
|
|
// Put the length in the proper field.
|
|
pStubMsg->ActualCount = (ulong)pStubMsg->MaxCount;
|
|
|
|
pStubMsg->MaxCount = OldMaxCount;
|
|
|
|
pStubMsg->StackTop = pOldStackTop;
|
|
|
|
return;
|
|
}
|
|
|
|
if ( (*pFormat & 0xf0) == FC_NORMAL_VARIANCE )
|
|
{
|
|
// Get the address where the variance variable is in the struct.
|
|
pLength = pMemory + *((signed short *)(pFormat + 2));
|
|
goto ComputeVarianceGetCount;
|
|
}
|
|
|
|
// See if this is an async split
|
|
|
|
if ( pFormat[1] & 0x20 )
|
|
{
|
|
fAsyncSplit = TRUE;
|
|
RpcpMemoryCopy( & FormatCopy[0], pFormat, 4 );
|
|
pFormat = (PFORMAT_STRING) & FormatCopy[0];
|
|
|
|
// Remove the async marker
|
|
FormatCopy[1] = pFormat[1] & 0xdf;
|
|
}
|
|
|
|
//
|
|
// Get a pointer to the variance variable.
|
|
//
|
|
if ( (*pFormat & 0xf0) == FC_TOP_LEVEL_VARIANCE )
|
|
{
|
|
//
|
|
// Top level variance. For /Os stubs, the stubs put the actual
|
|
// count and offset in the stub message. For /Oi stubs, we get the
|
|
// actual count via an offset from the stack top. The first_is must
|
|
// be zero if we get here.
|
|
//
|
|
if ( pStubMsg->StackTop )
|
|
{
|
|
if ( fAsyncSplit )
|
|
{
|
|
PNDR_DCOM_ASYNC_MESSAGE pAsyncMsg;
|
|
|
|
pAsyncMsg = (PNDR_DCOM_ASYNC_MESSAGE) pStubMsg->pAsyncMsg;
|
|
|
|
pLength = pAsyncMsg->BeginStack + *((signed short *)(pFormat + 2));
|
|
}
|
|
else
|
|
pLength = pStubMsg->StackTop + *((signed short *)(pFormat + 2));
|
|
goto ComputeVarianceGetCount;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If this is top level variance with /Os then we don't have
|
|
// to do anything, the proper variance values are placed in the
|
|
// stub message inline in the stubs.
|
|
//
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we're computing the length of an embedded size/length pointer then we
|
|
// use the memory pointer in the stub message, which points to the
|
|
// beginning of the embedding structure.
|
|
//
|
|
if ( (*pFormat & 0xf0) == FC_POINTER_VARIANCE )
|
|
{
|
|
pMemory = pStubMsg->Memory;
|
|
pLength = pMemory + *((signed short *)(pFormat + 2));
|
|
goto ComputeVarianceGetCount;
|
|
}
|
|
|
|
//
|
|
// Check for constant length.
|
|
//
|
|
if ( (*pFormat & 0xf0) == FC_CONSTANT_VARIANCE )
|
|
{
|
|
//
|
|
// The length is contained in the lower three bytes of the
|
|
// long currently pointed to by pFormat.
|
|
//
|
|
Length = (LONG_PTR) ((ulong)pFormat[1] << 16);
|
|
Length |= (LONG_PTR) *((ushort *)(pFormat + 2));
|
|
|
|
goto ComputeVarianceEnd;
|
|
}
|
|
|
|
//
|
|
// Check for variance of a multidimensional array element in
|
|
// a -Os stub.
|
|
//
|
|
if ( (*pFormat & 0xf0) == FC_TOP_LEVEL_MULTID_CONFORMANCE )
|
|
{
|
|
long Dimension;
|
|
|
|
if ( fAsyncSplit )
|
|
RpcRaiseException( RPC_X_WRONG_STUB_VERSION );
|
|
|
|
//
|
|
// If pArrayInfo is non-null than we have a multi-D array. If it
|
|
// is null then we have multi-leveled sized pointers.
|
|
//
|
|
if ( pStubMsg->pArrayInfo )
|
|
{
|
|
Dimension = pStubMsg->pArrayInfo->Dimension;
|
|
|
|
pStubMsg->Offset =
|
|
pStubMsg->pArrayInfo->OffsetArray[Dimension];
|
|
pStubMsg->ActualCount =
|
|
pStubMsg->pArrayInfo->ActualCountArray[Dimension];
|
|
}
|
|
else
|
|
{
|
|
Dimension = *((ushort *)(pFormat + 2));
|
|
|
|
pStubMsg->Offset = pStubMsg->SizePtrOffsetArray[Dimension];
|
|
pStubMsg->ActualCount = pStubMsg->SizePtrLengthArray[Dimension];
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
ComputeVarianceGetCount:
|
|
|
|
//
|
|
// Must check now if there is a dereference op.
|
|
//
|
|
if ( pFormat[1] == FC_DEREFERENCE )
|
|
{
|
|
pLength = *(void **)pLength;
|
|
}
|
|
|
|
//
|
|
// Now get the conformance count.
|
|
//
|
|
switch ( *pFormat & 0x0f )
|
|
{
|
|
case FC_ULONG :
|
|
Length = (LONG_PTR)*((ulong *)pLength);
|
|
break;
|
|
|
|
case FC_LONG :
|
|
Length = *((long *)pLength);
|
|
break;
|
|
|
|
case FC_USHORT :
|
|
Length = (long) *((ushort *)pLength);
|
|
break;
|
|
|
|
case FC_SHORT :
|
|
Length = (long) *((short *)pLength);
|
|
break;
|
|
|
|
case FC_USMALL :
|
|
Length = (long) *((uchar *)pLength);
|
|
break;
|
|
|
|
case FC_SMALL :
|
|
Length = (long) *((char *)pLength);
|
|
break;
|
|
|
|
default :
|
|
NDR_ASSERT(0,"NdrpComputeVariance : bad format");
|
|
RpcRaiseException( RPC_S_INTERNAL_ERROR );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Check the operator.
|
|
//
|
|
switch ( pFormat[1] )
|
|
{
|
|
case FC_DIV_2 :
|
|
Length /= 2;
|
|
break;
|
|
case FC_MULT_2 :
|
|
Length *= 2;
|
|
break;
|
|
case FC_SUB_1 :
|
|
Length -= 1;
|
|
break;
|
|
case FC_ADD_1 :
|
|
Length += 1;
|
|
break;
|
|
default :
|
|
// OK
|
|
break;
|
|
}
|
|
|
|
ComputeVarianceEnd:
|
|
|
|
// Get here if the length was computed directly.
|
|
pStubMsg->Offset = 0;
|
|
pStubMsg->ActualCount = (ulong) Length;
|
|
}
|