Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f7ca35dddd
WindowsXP-SP1/com/rpc/runtime/mtrt/dgpkt.cxx

2192 lines
58 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1994 - 1999
//
// File: dgpkt.cxx
//
//--------------------------------------------------------------------------
/*++
Module Name:
dgpkt.cxx
Abstract:
Author:
Jeff Roberts (jroberts) 22-May-1995
Revision History:
22-May-1995 jroberts
Created this module.
09-Jul-1997 edwardr
Added support for large packets (>65535) for Falcon/RPC.
--*/
#include <precomp.hxx>
#include <dgpkt.hxx>
unsigned long ProcessStartTime;
unsigned RandomCounter = 0x6789abce;
const unsigned
RpcToPacketFlagsArray[8] =
{
0,
DG_PF_IDEMPOTENT,
DG_PF_BROADCAST,
DG_PF_IDEMPOTENT | DG_PF_BROADCAST,
DG_PF_MAYBE,
DG_PF_IDEMPOTENT | DG_PF_MAYBE,
DG_PF_BROADCAST | DG_PF_MAYBE,
DG_PF_IDEMPOTENT | DG_PF_BROADCAST | DG_PF_MAYBE,
};
const unsigned
PacketToRpcFlagsArray[8] =
{
0 | 0 | 0 ,
RPC_NCA_FLAGS_MAYBE | 0 | 0 ,
0 | RPC_NCA_FLAGS_IDEMPOTENT | 0 ,
RPC_NCA_FLAGS_MAYBE | RPC_NCA_FLAGS_IDEMPOTENT | 0 ,
0 | 0 | RPC_NCA_FLAGS_BROADCAST,
RPC_NCA_FLAGS_MAYBE | 0 | RPC_NCA_FLAGS_BROADCAST,
0 | RPC_NCA_FLAGS_IDEMPOTENT | RPC_NCA_FLAGS_BROADCAST,
RPC_NCA_FLAGS_MAYBE | RPC_NCA_FLAGS_IDEMPOTENT | RPC_NCA_FLAGS_BROADCAST,
};
DG_PACKET_ENGINE::DG_PACKET_ENGINE(
unsigned char a_PacketType,
DG_PACKET * a_Packet,
RPC_STATUS * pStatus
) :
pSavedPacket (a_Packet),
PacketType (a_PacketType),
ReferenceCount (0),
BaseConnection (0),
SourceEndpoint (0),
RemoteAddress (0),
Buffer (0),
BufferLength (0),
QueuedBufferHead (0),
QueuedBufferTail (0),
pReceivedPackets (0),
pLastConsecutivePacket(0),
ConsecutiveDataBytes (0),
ReceiveFragmentBase (0),
CachedPacket (0),
LastReceiveBuffer (0),
LastReceiveBufferLength(0),
Cancelled (FALSE)
{
if (!a_Packet)
{
*pStatus = RPC_S_OUT_OF_MEMORY;
}
if (*pStatus)
{
return;
}
pSavedPacket->Header.RpcVersion = DG_RPC_PROTOCOL_VERSION;
pSavedPacket->Header.PacketFlags = 0;
SetMyDataRep(&pSavedPacket->Header);
#ifdef DEBUGRPC
BasePacketFlags = ~0;
#endif
}
void
DG_PACKET_ENGINE::ReadConnectionInfo(
DG_COMMON_CONNECTION * a_Connection,
DG_TRANSPORT_ADDRESS a_RemoteAddress
)
{
BaseConnection = a_Connection;
RemoteAddress = a_RemoteAddress;
CurrentPduSize = 0;
SetFragmentLengths();
pSavedPacket->Header.InterfaceHint = 0xffff;
RpcpMemoryCopy( &pSavedPacket->Header.ActivityId,
&a_Connection->ActivityNode.Uuid,
sizeof(UUID)
);
}
DG_PACKET_ENGINE::~DG_PACKET_ENGINE(
)
{
ASSERT( !LastReceiveBuffer );
ASSERT( !pReceivedPackets );
ASSERT( !QueuedBufferHead );
ASSERT( !Buffer );
if (pSavedPacket)
{
FreePacket(pSavedPacket);
}
if (CachedPacket)
{
FreePacket(CachedPacket);
}
CleanupReceiveWindow();
}
void
DG_PACKET_ENGINE::NewCall()
/*++
Routine Description:
A new call dawns.
Arguments:
Return Value:
none
--*/
{
ASSERT( !pLastConsecutivePacket );
ASSERT( !ConsecutiveDataBytes );
ASSERT( !LastReceiveBuffer );
SetFragmentLengths();
Buffer = 0;
fReceivedAllFragments = FALSE;
fRetransmitted = FALSE;
TimeoutCount = 0;
RepeatedFack = 0;
FackSerialNumber = 0;
SendSerialNumber = 0;
ReceiveSerialNumber = 0;
SendWindowBase = 0;
FirstUnsentFragment = 0;
SendBurstLength = SendWindowSize;
ReceiveFragmentBase = 0;
RingBufferBase = 0;
#ifdef DEBUGRPC
for (unsigned i=0; i < MAX_WINDOW_SIZE; i++)
{
FragmentRingBuffer[i].SerialNumber = 0xeeee0000;
FragmentRingBuffer[i].Length = 0xdd000000;
FragmentRingBuffer[i].Offset = 0xb000b000;
}
#endif
BasePacketFlags2 = 0;
}
RPC_STATUS
DG_PACKET_ENGINE::PushBuffer(
PRPC_MESSAGE Message
)
/*++
Function Description:
Submits a buffer to be sent over the network.
If a buffer is in progress, the new buffer is added to the
"pending" list. IF not, the buffer is placed in the "active" slot.
The only time a buffer will not go in the active slot is during an
async pipe call when the app is not waiting for send-complete
notifications before submitting new buffers.
Notes:
The buffer sent will be truncated to the nearest packet if
RPC_BUFFER_PARTIAL is set, and Message.BufferLength is set to
the amount actually sent.
--*/
{
// ASSERT( Buffer == 0 || IsBufferAcknowledged() );
RPC_STATUS Status = 0;
RPC_STATUS FixupStatus = 0;
unsigned FractionalPart = Message->BufferLength % MaxFragmentSize;
unsigned SendLength = Message->BufferLength;
if (Message->RpcFlags & RPC_BUFFER_PARTIAL)
{
SendLength -= FractionalPart;
}
if (!Buffer || IsBufferAcknowledged())
{
SetCurrentBuffer(Message->Buffer,
SendLength,
Message->RpcFlags
);
Status = SendSomeFragments();
}
else
{
QUEUED_BUFFER * Node = new QUEUED_BUFFER;
if (!Node)
{
return RPC_S_OUT_OF_MEMORY;
}
Node->Buffer = Message->Buffer;
Node->BufferLength = SendLength;
Node->BufferFlags = Message->RpcFlags;
Node->Next = 0;
if (QueuedBufferTail)
{
QueuedBufferTail->Next = Node;
}
else
{
ASSERT( !QueuedBufferHead );
QueuedBufferHead = Node;
}
QueuedBufferTail = Node;
Status = 0;
}
FixupStatus = FixupPartialSend(Message);
if (!Status)
{
Status = FixupStatus;
}
return Status;
}
RPC_STATUS
DG_PACKET_ENGINE::PopBuffer(
BOOL fSend
)
/*++
Function Description:
Move the next pending send buffer into the active send buffer slot.
This is a no-op except unless this is an async pipe call and the app
is not waiting for send-complete notifications.
Notes:
The buffer sent will be truncated to the nearest packet if
RPC_BUFFER_PARTIAL is set, and Message.BufferLength is set to
the amount actually sent.
--*/
{
RPC_STATUS Status = 0;
RPC_MESSAGE Message;
Message.Buffer = Buffer;
Message.BufferLength = BufferLength;
QUEUED_BUFFER * Node = QueuedBufferHead;
if (Node)
{
QueuedBufferHead = Node->Next;
if (!QueuedBufferHead)
{
QueuedBufferTail = 0;
}
SetCurrentBuffer(Node->Buffer, Node->BufferLength, Node->BufferFlags);
if (fSend)
{
Status = SendSomeFragments();
}
delete Node;
}
else
{
Buffer = 0;
BufferLength = 0;
BufferFlags = 0;
}
if (Message.Buffer)
{
CommonFreeBuffer(&Message);
}
return Status;
}
RPC_STATUS
DG_PACKET_ENGINE::FixupPartialSend(
RPC_MESSAGE * Message
)
/*++
Function Description:
This fn "does the right thing" with the unsent bit at the end of
a pipe send. For sync sends, this means moving the unsent bit
to the front of the existing buffer. For async sends, this means
allocating a new buffer and copying the unsent bit into it.
--*/
{
if (!(Message->RpcFlags & RPC_BUFFER_PARTIAL))
{
// We need this so Receive will be passed a null buffer
// unless the stub sticks one in the message.
Message->Buffer = 0;
Message->BufferLength = 0;
return RPC_S_OK;
}
unsigned FractionalPart;
// if (Message->RpcFlags & RPC_BUFFER_ASYNC)
// {
RPC_MESSAGE NewMessage;
FractionalPart = Message->BufferLength % MaxFragmentSize;
if (!FractionalPart)
{
Message->Buffer = 0;
Message->BufferLength = 0;
return RPC_S_OK;
}
DG_PACKET * Packet = DG_PACKET::AllocatePacket(CurrentPduSize);
if (!Packet)
{
return RPC_S_OUT_OF_MEMORY;
}
RpcpMemoryCopy(Packet->Header.Data,
((char *) Message->Buffer) + (Message->BufferLength - FractionalPart),
FractionalPart
);
Message->Buffer = Packet->Header.Data;
Message->BufferLength = FractionalPart;
// }
// else
// {
// char * Temp = (char *) Message->Buffer;
//
// FractionalPart = Message->BufferLength - FirstUnsentOffset;
// if (!FractionalPart)
// {
// return RPC_S_OK;
// }
//
// RpcpMemoryMove(Message->Buffer, Temp + FirstUnsentOffset, FractionalPart);
// Message->BufferLength = FractionalPart;
// }
return RPC_S_OK;
}
void
DG_PACKET_ENGINE::SetCurrentBuffer(
void * a_Buffer,
unsigned a_BufferLength,
unsigned long a_BufferFlags
)
{
Buffer = a_Buffer;
BufferLength = a_BufferLength;
BufferFlags = a_BufferFlags;
TimeoutCount = 0;
SendWindowBits = 0;
FirstUnsentOffset = 0;
if (BufferLength == 0)
{
FinalSendFrag = SendWindowBase;
}
else
{
FinalSendFrag = SendWindowBase + (BufferLength-1) / MaxFragmentSize;
}
}
RPC_STATUS
DG_PACKET_ENGINE::CommonGetBuffer(
RPC_MESSAGE * Message
)
{
unsigned char SubjectType;
void * Subject;
unsigned Length;
PDG_PACKET pPacket;
Length = sizeof(NCA_PACKET_HEADER)
+ Align8(Message->BufferLength)
+ SecurityTrailerSize;
unsigned BaseLength = BaseConnection->TransportInterface->BasePduSize;
// if (Length <= BaseLength)
// {
// pPacket = DG_PACKET::AllocatePacket(BaseLength);
// }
// else if (Length <= CurrentPduSize)
// {
// pPacket = AllocatePacket();
// }
// else
{
pPacket = DG_PACKET::AllocatePacket(Length);
}
if (0 == pPacket)
{
return RPC_S_OUT_OF_MEMORY;
}
//
// Point the buffer at the appropriate place in the packet.
//
Message->Buffer = pPacket->Header.Data;
// if (pPacket->MaxDataLength < 256)
// {
// AddActivePacket(pPacket);
// }
return RPC_S_OK;
}
void
DG_PACKET_ENGINE::CommonFreeBuffer(
RPC_MESSAGE * Message
)
{
if (!Message->Buffer)
{
return;
}
PDG_PACKET Packet = DG_PACKET::FromStubData(Message->Buffer);
LogEvent(SU_ENGINE, EV_PROC, this, Message->Buffer, 'F' + (('B' + (('u' + ('f' << 8)) << 8)) << 8));
ASSERT( Packet->MaxDataLength < 0x7fffffffUL );
// if (Packet && Packet->MaxDataLength < 256)
// {
// RemoveActivePacket(Packet);
// }
FreePacket(Packet);
if (Message->Buffer == LastReceiveBuffer)
{
LastReceiveBuffer = 0;
LastReceiveBufferLength = 0;
}
Message->Buffer = 0;
}
RPC_STATUS
DG_PACKET_ENGINE::CommonReallocBuffer(
IN RPC_MESSAGE * Message,
IN unsigned int NewSize
)
{
if (Message->Buffer == LastReceiveBuffer &&
NewSize <= LastReceiveBufferLength)
{
Message->BufferLength = NewSize;
return RPC_S_OK;
}
RPC_STATUS Status;
RPC_MESSAGE NewMessage;
NewMessage.BufferLength = NewSize;
Status = CommonGetBuffer(&NewMessage);
if (RPC_S_OK != Status)
{
return Status;
}
LastReceiveBuffer = NewMessage.Buffer;
LastReceiveBufferLength = NewMessage.BufferLength;
if (NewSize >= Message->BufferLength)
{
RpcpMemoryCopy(NewMessage.Buffer,
Message->Buffer,
Message->BufferLength
);
}
CommonFreeBuffer(Message);
Message->Buffer = NewMessage.Buffer;
Message->BufferLength = NewMessage.BufferLength;
return RPC_S_OK;
}
void
DG_PACKET_ENGINE::CleanupSendWindow()
{
while (Buffer)
{
PopBuffer(FALSE);
}
}
void
DG_PACKET_ENGINE::CleanupReceiveWindow()
{
//
// Free any response packets.
//
while (pReceivedPackets)
{
PDG_PACKET Next = pReceivedPackets->pNext;
FreePacket(pReceivedPackets);
pReceivedPackets = Next;
}
pLastConsecutivePacket = 0;
ConsecutiveDataBytes = 0;
}
RPC_STATUS
DG_PACKET_ENGINE::SendSomeFragments()
/*++
Routine Description:
Sends some fragments of the user buffer.
Arguments:
Return Value:
result of the send operation
--*/
{
RPC_STATUS Status = RPC_S_OK;
unsigned short i = 0;
unsigned short AckFragment;
unsigned short Frag;
unsigned short Remainder;
unsigned Offset;
unsigned FragmentsSent = 0;
#ifdef DEBUGRPC
if (!Buffer &&
(BufferFlags & RPC_BUFFER_PARTIAL))
{
// return RPC_S_SEND_INCOMPLETE;
RpcpBreakPoint();
}
#endif
if (SendBurstLength > SendWindowSize)
{
SendBurstLength = SendWindowSize;
}
//
// If we can extend the window, do so; otherwise, resend old packets.
//
if (FirstUnsentFragment <= FinalSendFrag &&
FirstUnsentFragment < SendWindowBase + SendWindowSize)
{
unsigned short ThisBurstLength;
Frag = FirstUnsentFragment;
ThisBurstLength = SendBurstLength;
if (ThisBurstLength > FinalSendFrag + 1 - Frag)
{
ThisBurstLength = FinalSendFrag + 1 - Frag;
}
if (Frag + ThisBurstLength > SendWindowBase + SendWindowSize)
{
ThisBurstLength = (SendWindowBase + SendWindowSize) - Frag;
}
while (++FragmentsSent <= ThisBurstLength && Status == RPC_S_OK)
{
if (FragmentsSent == ThisBurstLength &&
(Frag != FinalSendFrag || (BufferFlags & RPC_BUFFER_PARTIAL) || (BasePacketFlags2 & DG_PF2_UNRELATED)))
{
Status = SendFragment(Frag, PacketType, TRUE);
}
else
{
Status = SendFragment(Frag, PacketType, FALSE);
}
++Frag;
}
//
// Cut down the burst length if our window is maxed out.
//
if (Frag - SendWindowBase >= SendWindowSize)
{
SendBurstLength = (1+SendBurstLength)/2;
}
}
if (0 == FragmentsSent && !IsBufferAcknowledged())
{
// We can get here if all the unacknowledged fragments have serial
// numbers greater than the one the client last acknowledged, and
// the window is also maxed out.
//
// This could mean the network is very slow, or the unack'ed packets
// have been lost.
//
Status = SendFragment(SendWindowBase, PacketType, TRUE);
}
return Status;
}
RPC_STATUS
DG_PACKET_ENGINE::SendFragment(
unsigned FragNum,
unsigned char PacketType,
BOOL fFack
)
{
NCA_PACKET_HEADER PriorData;
UNALIGNED NCA_PACKET_HEADER __RPC_FAR * pHeader;
//
// Figure out where the packet starts and how long it is.
//
unsigned Offset;
unsigned Length;
unsigned Index = (FragNum - SendWindowBase + RingBufferBase) % MAX_WINDOW_SIZE;
unsigned DistanceToEnd;
if (FragNum < FirstUnsentFragment)
{
Offset = FragmentRingBuffer[Index].Offset;
Length = FragmentRingBuffer[Index].Length;
DistanceToEnd = BufferLength - Offset;
#ifdef DEBUGRPC
if (Offset >= 0xb000b000 || Length >= 0xdd000000)
{
RpcpBreakPoint();
}
#endif
fRetransmitted = TRUE;
}
else
{
ASSERT(FragNum == FirstUnsentFragment);
Offset = FirstUnsentOffset;
Length = MaxFragmentSize;
DistanceToEnd = BufferLength - Offset;
if (DistanceToEnd < Length)
{
Length = DistanceToEnd;
}
FirstUnsentOffset += Length;
FirstUnsentFragment = 1 + FragNum;
}
if (BufferLength)
{
// this is harmless and can sometimes be triggered on the first call of an activity
// ASSERT(Length);
// ASSERT(Offset < BufferLength);
}
else
{
ASSERT(!Length);
ASSERT(!Offset);
}
//
// Time to start assembling the buffer.
//
pHeader = (PNCA_PACKET_HEADER) (PCHAR(Buffer) - sizeof(NCA_PACKET_HEADER));
*pHeader = pSavedPacket->Header;
pHeader->PacketType = PacketType;
pHeader->PacketFlags = BasePacketFlags;
pHeader->PacketFlags2 = BasePacketFlags2;
if (FinalSendFrag != 0 ||
(BufferFlags & RPC_BUFFER_PARTIAL))
{
pHeader->PacketFlags |= DG_PF_FRAG;
if (FragNum == FinalSendFrag &&
0 == (BufferFlags & RPC_BUFFER_PARTIAL))
{
pHeader->PacketFlags |= DG_PF_LAST_FRAG;
}
}
pHeader->SetPacketBodyLen (Length);
pHeader->SetFragmentNumber((unsigned short) FragNum);
if (FALSE == fFack)
{
pHeader->PacketFlags |= DG_PF_NO_FACK;
}
AddSerialNumber(pHeader);
RPC_STATUS Status;
//
// Stub data is encrypted in-place; we need not to encrypt the original data
// so we can retransmit it if necessary.
//
unsigned Frag = (pHeader->PacketType << 16) | pHeader->GetFragmentNumber();
LogEvent(SU_ENGINE, EV_PKT_OUT, this, 0, Frag);
if (BaseConnection->ActiveSecurityContext &&
BaseConnection->ActiveSecurityContext->AuthenticationLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
{
RpcpMemoryCopy(&pSavedPacket->Header, pHeader, sizeof(NCA_PACKET_HEADER));
RpcpMemoryCopy(pSavedPacket->Header.Data, pHeader->Data + Offset, pHeader->GetPacketBodyLen());
Status = BaseConnection->SealAndSendPacket(SourceEndpoint, RemoteAddress, &pSavedPacket->Header, 0);
}
else
{
Status = BaseConnection->SealAndSendPacket(SourceEndpoint, RemoteAddress, pHeader, Offset);
}
FragmentRingBuffer[Index].SerialNumber = SendSerialNumber;
FragmentRingBuffer[Index].Length = Length;
FragmentRingBuffer[Index].Offset = Offset;
++SendSerialNumber;
if (Status)
{
LogError(SU_ENGINE, EV_STATUS, this, 0, Status);
}
return Status;
}
RPC_STATUS
DG_PACKET_ENGINE::UpdateSendWindow(
PDG_PACKET pPacket,
BOOL * pfUpdated
)
/*++
Routine Description:
Update the send window based upon a received FACK or NOCALL.
The caller should filter out other packet types.
Arguments:
pPacket - the packet received
Return Value:
return code:
TRUE if PDU size or window size changed
FALSE if not
--*/
{
RPC_STATUS Status = 0;
FACK_BODY_VER_0 PAPI * pBody = (FACK_BODY_VER_0 PAPI *) pPacket->Header.Data;
*pfUpdated = FALSE;
unsigned short Diff;
unsigned short RemoteBase = 1+pPacket->GetFragmentNumber();
ASSERT(pPacket->TimeReceived == 0x31415926);
//
// Check that we can understand this packet.
//
if (0 != pPacket->GetPacketBodyLen())
{
//
// Version 0 and version 1 are identical.
//
if (0 != pBody->Version &&
1 != pBody->Version)
{
#ifdef DEBUGRPC
PrintToDebugger("RPC DG: warning - FACK body version %u\n", pBody->Version);
#endif
pPacket->SetPacketBodyLen(0);
}
else if (pPacket->GetPacketBodyLen() < sizeof(FACK_BODY_VER_0))
{
#ifdef DEBUGRPC
PrintToDebugger("RPC DG: warning - FACK body truncated\n");
#endif
pPacket->SetPacketBodyLen(0);
}
else if (pPacket->GetPacketBodyLen() < sizeof(FACK_BODY_VER_0) + pBody->AckWordCount * sizeof(unsigned long))
{
#ifdef DEBUGRPC
PrintToDebugger("RPC DG: warning - FACK body length inconsistent\n");
#endif
pPacket->SetPacketBodyLen(0);
}
else
{
if (NeedsByteSwap(&pPacket->Header))
{
ByteSwapFackBody0(pBody);
}
//
// NT 1057 used 0xffff to signal no packets have been received.
// This doesn't match OSF.
//
if (0xffff == pBody->SerialNumber)
{
pBody->SerialNumber = 0;
}
//
// If the other guy is resending the same FACK, we should resend.
// If it's different, then we are likely OK.
//
if (pBody->SerialNumber == FackSerialNumber)
{
goto send;
}
if (pBody->SerialNumber < FackSerialNumber)
{
FackSerialNumber = pBody->SerialNumber;
goto dont_send;
}
FackSerialNumber = pBody->SerialNumber;
}
}
//
// Update send window.
//
if (RemoteBase < SendWindowBase)
{
//
// Fragments previously acknowledged are now missing. Either this
// packet was delivered out of order, or the server crashed and
// restarted. Ignore the packet.
//
goto dont_send;
}
if (RemoteBase > FirstUnsentFragment)
{
#ifdef DEBUGRPC
PrintToDebugger("RPC DG: bogus FACK packet received\n");
#endif
goto dont_send;
}
//
// We are moving the window base forward. We need to advance the
// ring buffer base by the same amount, and clear the entries
// corresponding to unsent packets.
//
Diff = RemoteBase - SendWindowBase;
ASSERT(Diff <= MAX_WINDOW_SIZE);
#ifdef DEBUGRPC
while (Diff)
{
FragmentRingBuffer[RingBufferBase].SerialNumber |= 0xeeee0000;
FragmentRingBuffer[RingBufferBase].Length |= 0xdd000000;
FragmentRingBuffer[RingBufferBase].Offset |= 0xb0000000;
++RingBufferBase;
RingBufferBase %= MAX_WINDOW_SIZE;
--Diff;
}
#else
RingBufferBase += Diff;
RingBufferBase %= MAX_WINDOW_SIZE;
#endif
SendWindowBase = RemoteBase;
SendWindowBits = 0;
ASSERT( SendWindowBase <= FirstUnsentFragment );
if (IsBufferAcknowledged())
{
PopBuffer(FALSE);
}
if (0 != pPacket->GetPacketBodyLen())
{
LogEvent(SU_ENGINE, EV_WINDOW, this, (void *) pBody->WindowSize, pBody->Acks[0]);
if (pBody->AckWordCount)
{
//
// Save missing-packet bitmask.
//
SendWindowBits = pBody->Acks[0];
}
//
// Adjust window size.
//
if (pBody->WindowSize > MAX_WINDOW_SIZE)
{
pBody->WindowSize = MAX_WINDOW_SIZE;
}
SendWindowSize = pBody->WindowSize;
if (SendBurstLength > SendWindowSize)
{
SendBurstLength = SendWindowSize;
}
//
// Adjust maximum PDU length.
//
unsigned NewPduSize;
NewPduSize = pBody->MaxDatagramSize;
if (NewPduSize > SourceEndpoint->Stats.PreferredPduSize)
{
NewPduSize = SourceEndpoint->Stats.PreferredPduSize;
}
BaseConnection->CurrentPduSize = (unsigned short) NewPduSize;
BaseConnection->RemoteWindowSize = pBody->WindowSize;
//
// If no packets are getting through, we probably are sending
// packets that are too large.
//
if (0 == RemoteBase &&
0 == SendWindowBits &&
NewPduSize < CurrentPduSize)
{
CurrentPduSize = (unsigned short) NewPduSize;
SetFragmentLengths();
FirstUnsentFragment = 0;
FirstUnsentOffset = 0;
FinalSendFrag = SendWindowBase + (BufferLength-1) / MaxFragmentSize;
}
*pfUpdated = TRUE;
}
send:
Status = SendSomeFragments();
dont_send:
return Status;
}
BOOL
DG_PACKET_ENGINE::UpdateReceiveWindow(
PDG_PACKET pPacket
)
/*++
Routine Description:
Adds a fragment to the receive list, and sends a FACK.
Arguments:
Return Value:
--*/
{
ASSERT(pPacket->TimeReceived == 0x31415926);
//
// Don't retain data from previous pipe buffers.
//
if (pPacket->GetFragmentNumber() < ReceiveFragmentBase)
{
if (0 == (pPacket->Header.PacketFlags & DG_PF_NO_FACK))
{
SendFackOrNocall(pPacket, DG_FACK);
}
return FALSE;
}
//
// Attempt to guess the client's max PDU size. Round down to a multiple
// of eight, for NDR.
//
if (pPacket->DataLength + sizeof(NCA_PACKET_HEADER) > BaseConnection->CurrentPduSize)
{
unsigned RemoteTransportBuffer = BaseConnection->CurrentPduSize * BaseConnection->RemoteWindowSize;
BaseConnection->CurrentPduSize = ((pPacket->DataLength + sizeof(NCA_PACKET_HEADER)) & ~7);
BaseConnection->RemoteWindowSize = RemoteTransportBuffer / BaseConnection->CurrentPduSize;
if (0 == BaseConnection->RemoteWindowSize)
{
BaseConnection->RemoteWindowSize = 1;
}
}
PNCA_PACKET_HEADER pHeader = &pPacket->Header;
unsigned short Serial = ReadSerialNumber(pHeader);
if (Serial > ReceiveSerialNumber)
{
ReceiveSerialNumber = Serial;
}
//
// Authentication levels above AUTHN_LEVEL_PKT will checksum the packet,
// so we must remove these bits from the header.
//
pPacket->Header.PacketFlags &= ~(DG_PF_FORWARDED);
pPacket->Header.PacketFlags2 &= ~(DG_PF2_FORWARDED_2);
//
// Check the easy case: is this a single packet call?
//
if ((pHeader->PacketFlags & DG_PF_FRAG) == 0 &&
(pHeader->PacketFlags & DG_PF_LAST_FRAG) == 0)
{
if (pReceivedPackets)
{
ASSERT( pReceivedPackets->Header.SequenceNumber == pPacket->Header.SequenceNumber );
return FALSE;
}
pReceivedPackets = pPacket;
pLastConsecutivePacket = pPacket;
pPacket->pNext = pPacket->pPrevious = 0;
ConsecutiveDataBytes += pHeader->GetPacketBodyLen();
fReceivedAllFragments = TRUE;
return TRUE;
}
//
// This is a multi-packet call. Insert the packet in pReceivedPackets
// and send a FACK.
//
PDG_PACKET pScan;
PDG_PACKET pTrail;
BOOL PacketAddedToList = TRUE;
if (pReceivedPackets == 0)
{
pReceivedPackets = pPacket;
if (ReceiveFragmentBase == pHeader->GetFragmentNumber())
{
pLastConsecutivePacket = pPacket;
ConsecutiveDataBytes += pHeader->GetPacketBodyLen();
}
pPacket->pNext = pPacket->pPrevious = 0;
}
else
{
//
// Not the first packet to be received. So scan for its place in the
// list.
//
unsigned short FragNum = pHeader->GetFragmentNumber();
if (pLastConsecutivePacket)
{
pScan = pLastConsecutivePacket;
}
else
{
pScan = pReceivedPackets;
}
pTrail = 0;
while (pScan && pScan->GetFragmentNumber() < FragNum)
{
ASSERT(pScan->TimeReceived == 0x31415926);
ASSERT(pScan->Header.SequenceNumber == SequenceNumber);
pTrail = pScan;
pScan = pScan->pNext;
}
if (pScan != 0)
{
if (pScan->GetFragmentNumber() > FragNum)
{
if (pScan->pPrevious &&
pScan->pPrevious->GetFragmentNumber() >= FragNum)
{
//
// The new packet is a duplicate of a preexisting one
// upstream from pLastConsecutivePacket.
//
PacketAddedToList = FALSE;
}
else
{
//
// Our fragment fills a gap in the series.
//
pPacket->pPrevious = pScan->pPrevious;
pPacket->pNext = pScan;
if (pScan->pPrevious == 0)
{
pReceivedPackets = pPacket;
}
else
{
pScan->pPrevious->pNext = pPacket;
}
pScan->pPrevious = pPacket;
}
}
else
{
//
// The new packet is a duplicate of a preexisting one
// downstream from pLastConsecutivePacket.
//
PacketAddedToList = FALSE;
}
}
else
{
//
// The fragnum is larger than everything seen so far.
//
pTrail->pNext = pPacket;
pPacket->pPrevious = pTrail;
pPacket->pNext = 0;
}
}
if (TRUE == PacketAddedToList)
{
//
// Scan the list for the first missing fragment.
//
unsigned short ScanNum;
if (pLastConsecutivePacket)
{
pScan = pLastConsecutivePacket->pNext;
ScanNum = pLastConsecutivePacket->GetFragmentNumber() + 1;
}
else
{
pScan = pReceivedPackets;
ScanNum = ReceiveFragmentBase;
}
while (pScan)
{
if (ScanNum == pScan->GetFragmentNumber())
{
ConsecutiveDataBytes += pScan->GetPacketBodyLen();
pLastConsecutivePacket = pScan;
}
pScan = pScan->pNext;
++ScanNum;
}
//
// We have updated pLastConsecutivePacket; is the whole buffer here?
//
if (pLastConsecutivePacket &&
pLastConsecutivePacket->Header.PacketFlags & DG_PF_LAST_FRAG)
{
fReceivedAllFragments = TRUE;
}
}
ASSERT(pReceivedPackets);
//
// Fack the fragment if necessary.
//
if (0 == (pHeader->PacketFlags & DG_PF_NO_FACK))
{
SendFackOrNocall(pPacket, DG_FACK);
}
return PacketAddedToList;
}
RPC_STATUS
DG_PACKET_ENGINE::SendFackOrNocall(
PDG_PACKET pPacket,
unsigned char PacketType
)
{
unsigned ReceiveWindowSize;
ReceiveWindowSize = SourceEndpoint->Stats.ReceiveBufferSize
/ ((1+SourceEndpoint->NumberOfCalls) * CurrentPduSize);
if (0 == ReceiveWindowSize)
{
ReceiveWindowSize = 1;
}
else if (ReceiveWindowSize > MAX_WINDOW_SIZE)
{
ReceiveWindowSize = MAX_WINDOW_SIZE;
}
pSavedPacket->Header.PacketType = PacketType;
pSavedPacket->Header.SequenceNumber = SequenceNumber;
pSavedPacket->Header.PacketFlags2 = 0;
FACK_BODY_VER_0 PAPI * pBody = (FACK_BODY_VER_0 PAPI *) pSavedPacket->Header.Data;
pBody->Version = 1;
pBody->Pad1 = 0;
pBody->MaxDatagramSize = SourceEndpoint->Stats.PreferredPduSize;
pBody->MaxPacketSize = SourceEndpoint->Stats.MaxPacketSize;
pBody->AckWordCount = 1;
pBody->WindowSize = (unsigned short) ReceiveWindowSize;
if (pPacket)
{
pBody->SerialNumber = ReadSerialNumber(&pPacket->Header);
}
else
{
pBody->SerialNumber = ReceiveSerialNumber;
}
unsigned short FragNum = ReceiveFragmentBase-1;
PDG_PACKET pScan = 0;
if (pLastConsecutivePacket)
{
FragNum = pLastConsecutivePacket->GetFragmentNumber();
pScan = pLastConsecutivePacket->pNext;
}
else if (pReceivedPackets)
{
pScan = pReceivedPackets->pNext;
}
unsigned Bit;
pBody->Acks[0] = 0;
while ( pScan )
{
Bit = pScan->GetFragmentNumber() - FragNum - 1;
pBody->Acks[0] |= (1 << Bit);
pScan = pScan->pNext;
}
if (pBody->Acks[0] == 0)
{
pBody->AckWordCount = 0;
}
pSavedPacket->SetPacketBodyLen( sizeof(FACK_BODY_VER_0) + sizeof(unsigned long) );
pSavedPacket->SetFragmentNumber(FragNum);
AddSerialNumber(&pSavedPacket->Header);
unsigned Frag = (pSavedPacket->Header.PacketType << 16) | pSavedPacket->GetFragmentNumber();
LogEvent(SU_ENGINE, EV_PKT_OUT, this, 0, Frag);
RPC_STATUS Status;
Status = BaseConnection->SealAndSendPacket(SourceEndpoint, RemoteAddress, &pSavedPacket->Header, 0);
if (Status)
{
LogError(SU_ENGINE, EV_STATUS, this, 0, Status);
}
return Status;
}
RPC_STATUS
DG_PACKET_ENGINE::AssembleBufferFromPackets(
RPC_MESSAGE * Message,
CALL * Call
)
/*++
Routine Description:
This function coalesces the list of consecutive packets into a monolithic
buffer.
Arguments:
Message - if .Buffer != 0 , use it. Otherwise allocate one.
Call - in case we need to call GetBuffer
Return Value:
RPC_S_OK - success
RPC_S_OUT_OF_MEMORY - we couldn't allocate or reallocate Message.Buffer
--*/
{
ASSERT( pLastConsecutivePacket );
//
// If only one packet is available, use the packet buffer itself.
//
if (0 == Message->Buffer && 0 == pReceivedPackets->pNext)
{
ASSERT(ConsecutiveDataBytes == pReceivedPackets->GetPacketBodyLen());
Message->Buffer = pReceivedPackets->Header.Data;
Message->BufferLength = ConsecutiveDataBytes;
Message->DataRepresentation = 0x00ffffff & (*(unsigned long PAPI *) &pReceivedPackets->Header.DataRep);
if (0 == (pReceivedPackets->Header.PacketFlags & DG_PF_FRAG))
{
Message->RpcFlags |= RPC_BUFFER_COMPLETE;
}
if (pReceivedPackets->Header.PacketFlags & DG_PF_LAST_FRAG)
{
Message->RpcFlags |= RPC_BUFFER_COMPLETE;
}
pReceivedPackets = 0;
pLastConsecutivePacket = 0;
ConsecutiveDataBytes = 0;
++ReceiveFragmentBase;
LastReceiveBuffer = Message->Buffer;
LastReceiveBufferLength = Message->BufferLength;
return RPC_S_OK;
}
//
// Get a buffer if we need it.
//
RPC_STATUS Status;
if (0 == Message->Buffer)
{
ASSERT(0 == (Message->RpcFlags & RPC_BUFFER_EXTRA));
Message->BufferLength = ConsecutiveDataBytes;
Status = Call->GetBuffer(Message, 0);
if (RPC_S_OK != Status)
{
return Status;
}
LastReceiveBuffer = Message->Buffer;
LastReceiveBufferLength = Message->BufferLength;
}
//
// Reallocate the buffer if it is too small.
//
char __RPC_FAR * CopyBuffer = (char __RPC_FAR *) Message->Buffer;
if (Message->RpcFlags & (RPC_BUFFER_EXTRA | RPC_BUFFER_PARTIAL))
{
ASSERT( !LastReceiveBufferLength ||
(CopyBuffer >= LastReceiveBuffer &&
CopyBuffer <= ((char __RPC_FAR *) LastReceiveBuffer) + LastReceiveBufferLength) );
if (0 == (Message->RpcFlags & RPC_BUFFER_EXTRA))
{
Message->BufferLength = 0;
}
unsigned Offset = Message->BufferLength;
CopyBuffer += Offset;
if (CopyBuffer + ConsecutiveDataBytes > ((char __RPC_FAR *) LastReceiveBuffer) + LastReceiveBufferLength)
{
Status = I_RpcReallocPipeBuffer(Message, Offset + ConsecutiveDataBytes);
if (RPC_S_OK != Status)
{
return Status;
}
CopyBuffer = (char __RPC_FAR *) Message->Buffer + Offset;
}
else
{
Message->BufferLength += ConsecutiveDataBytes;
}
}
else
{
Message->BufferLength = ConsecutiveDataBytes;
}
Message->DataRepresentation = 0x00ffffff & (*(unsigned long PAPI *) &pReceivedPackets->Header.DataRep);
{
PDG_PACKET pkt = DG_PACKET::FromStubData(Message->Buffer);
ASSERT( pkt->MaxDataLength >= Message->BufferLength );
}
//
// Copy the stub data into the buffer.
//
#ifdef DEBUGRPC
unsigned long Count = 0;
#endif
PDG_PACKET Packet;
BOOL fLastPacket = FALSE;
do
{
ASSERT(pReceivedPackets->TimeReceived == 0x31415926);
ASSERT(ReceiveFragmentBase == pReceivedPackets->GetFragmentNumber());
if (pReceivedPackets == pLastConsecutivePacket)
{
fLastPacket = TRUE;
if (0 == (pReceivedPackets->Header.PacketFlags & DG_PF_FRAG))
{
Message->RpcFlags |= RPC_BUFFER_COMPLETE;
}
if (pReceivedPackets->Header.PacketFlags & DG_PF_LAST_FRAG)
{
Message->RpcFlags |= RPC_BUFFER_COMPLETE;
}
}
unsigned Length = pReceivedPackets->GetPacketBodyLen();
RpcpMemoryCopy(CopyBuffer, pReceivedPackets->Header.Data, Length);
#ifdef DEBUGRPC
Count += Length;
#endif
CopyBuffer += Length;
Packet = pReceivedPackets;
pReceivedPackets = pReceivedPackets->pNext;
ASSERT(!pReceivedPackets || pReceivedPackets->pPrevious == Packet);
FreePacket(Packet);
++ReceiveFragmentBase;
}
while (!fLastPacket);
ASSERT(Count == ConsecutiveDataBytes);
ASSERT(fLastPacket || 0 == Count % 8);
pLastConsecutivePacket = 0;
ConsecutiveDataBytes = 0;
if (pReceivedPackets)
{
pReceivedPackets->pPrevious = 0;
}
return RPC_S_OK;
}
void
DG_PACKET_ENGINE::SetFragmentLengths()
{
PSECURITY_CONTEXT pSecurityContext = BaseConnection->ActiveSecurityContext;
if (0 == pSecurityContext)
{
SecurityTrailerSize = 0;
}
else switch (pSecurityContext->AuthenticationLevel)
{
case RPC_C_AUTHN_LEVEL_NONE:
{
SecurityTrailerSize = 0;
break;
}
case RPC_C_AUTHN_LEVEL_PKT:
case RPC_C_AUTHN_LEVEL_PKT_INTEGRITY:
{
SecurityTrailerSize = (unsigned short) pSecurityContext->MaximumSignatureLength();
SecurityTrailerSize += (unsigned short) Align4(sizeof(DG_SECURITY_TRAILER));
break;
}
case RPC_C_AUTHN_LEVEL_PKT_PRIVACY:
{
SecurityTrailerSize = (unsigned short) pSecurityContext->MaximumHeaderLength();
SecurityTrailerSize += (unsigned short) Align(sizeof(DG_SECURITY_TRAILER), Align4(pSecurityContext->BlockSize()));
break;
}
default:
{
ASSERT(0 && "RPC: unknown protect level");
break;
}
}
if (CurrentPduSize != BaseConnection->CurrentPduSize)
{
CurrentPduSize = (unsigned short) BaseConnection->CurrentPduSize;
SendWindowSize = (unsigned short) BaseConnection->RemoteWindowSize;
}
MaxFragmentSize = CurrentPduSize - sizeof(NCA_PACKET_HEADER);
if (SecurityTrailerSize)
{
MaxFragmentSize -= SecurityTrailerSize;
MaxFragmentSize -= MaxFragmentSize % SECURITY_HEADER_ALIGNMENT;
}
}
void
ByteSwapPacketHeader(
PDG_PACKET pPacket
)
/*++
Routine Description:
Byte swaps the packet header of the specified packet.
Arguments:
pPacket - Pointer to the packet whose header needs byte swapping.
Return Value:
<none>
--*/
{
unsigned long __RPC_FAR * VerNum = (unsigned long __RPC_FAR *) &(pPacket->Header.InterfaceVersion);
ByteSwapUuid(&(pPacket->Header.ObjectId));
ByteSwapUuid(&(pPacket->Header.InterfaceId));
ByteSwapUuid(&(pPacket->Header.ActivityId));
pPacket->Header.ServerBootTime = RpcpByteSwapLong(pPacket->Header.ServerBootTime);
*VerNum = RpcpByteSwapLong(*VerNum);
pPacket->Header.SequenceNumber = RpcpByteSwapLong(pPacket->Header.SequenceNumber);
pPacket->Header.OperationNumber = RpcpByteSwapShort(pPacket->Header.OperationNumber);
pPacket->Header.InterfaceHint = RpcpByteSwapShort(pPacket->Header.InterfaceHint);
pPacket->Header.ActivityHint = RpcpByteSwapShort(pPacket->Header.ActivityHint);
pPacket->Header.PacketBodyLen = RpcpByteSwapShort(pPacket->Header.PacketBodyLen);
pPacket->Header.FragmentNumber = RpcpByteSwapShort(pPacket->Header.FragmentNumber);
}
void
ByteSwapFackBody0(
FACK_BODY_VER_0 __RPC_FAR * pBody
)
{
pBody->WindowSize = RpcpByteSwapShort(pBody->WindowSize);
pBody->MaxDatagramSize = RpcpByteSwapLong (pBody->MaxDatagramSize);
pBody->MaxPacketSize = RpcpByteSwapLong (pBody->MaxPacketSize);
pBody->SerialNumber = RpcpByteSwapShort(pBody->SerialNumber);
pBody->AckWordCount = RpcpByteSwapShort(pBody->AckWordCount);
unsigned u;
for (u=0; u < pBody->AckWordCount; ++u)
{
pBody->Acks[u] = RpcpByteSwapLong (pBody->Acks[u]);
}
}
RPCRTAPI RPC_STATUS RPC_ENTRY
I_RpcTransDatagramAllocate(
IN DG_TRANSPORT_ENDPOINT TransportEndpoint,
OUT BUFFER *pBuffer,
OUT PUINT pBufferLength,
OUT DatagramTransportPair **pAddressPair
)
{
DG_ENDPOINT * Endpoint = DG_ENDPOINT::FromEndpoint(TransportEndpoint);
RPC_DATAGRAM_TRANSPORT * Transport = Endpoint->TransportInterface;
if ( !Endpoint->Stats.PreferredPduSize )
{
RpcpBreakPoint();
}
DG_PACKET * Packet = DG_PACKET::AllocatePacket(Endpoint->Stats.PreferredPduSize
+ Transport->AddressSize
+ sizeof(DatagramTransportPair));
if (!Packet)
{
return RPC_S_OUT_OF_MEMORY;
}
DG_TRANSPORT_ADDRESS Address = DG_TRANSPORT_ADDRESS(Packet->Header.Data - sizeof(NCA_PACKET_HEADER) + Endpoint->Stats.PreferredPduSize);
*pBuffer = &Packet->Header;
*pBufferLength = Endpoint->Stats.PreferredPduSize;
*pAddressPair = (DatagramTransportPair *)((char *)Address + Transport->AddressSize);
(*pAddressPair)->RemoteAddress = Address;
return RPC_S_OK;
}
RPCRTAPI RPC_STATUS RPC_ENTRY
I_RpcTransDatagramAllocate2(
IN DG_TRANSPORT_ENDPOINT TransportEndpoint,
OUT BUFFER *pBuffer,
IN OUT PUINT pBufferLength,
OUT DG_TRANSPORT_ADDRESS *pAddress
)
{
DG_ENDPOINT *pEndpoint = DG_ENDPOINT::FromEndpoint(TransportEndpoint);
RPC_DATAGRAM_TRANSPORT *pTransport = pEndpoint->TransportInterface;
DWORD dwSize = *pBufferLength;
if (dwSize < pEndpoint->Stats.PreferredPduSize)
{
dwSize = pEndpoint->Stats.PreferredPduSize;
}
DG_PACKET * Packet = DG_PACKET::AllocatePacket( dwSize + pTransport->AddressSize);
if (!Packet)
{
return RPC_S_OUT_OF_MEMORY;
}
DG_TRANSPORT_ADDRESS Address = DG_TRANSPORT_ADDRESS(Packet->Header.Data - sizeof(NCA_PACKET_HEADER) + dwSize);
*pBuffer = &Packet->Header;
*pBufferLength = dwSize;
*pAddress = Address;
return RPC_S_OK;
}
RPCRTAPI RPC_STATUS RPC_ENTRY
I_RpcTransDatagramFree(
IN RPC_TRANSPORT_ADDRESS ThisAddress,
IN BUFFER Buffer
)
{
DG_PACKET * Packet = DG_PACKET::FromPacketHeader( Buffer );
Packet->Free();
return RPC_S_OK;
}
RPC_STATUS
DG_PACKET::Initialize(
)
{
return RPC_S_OK;
}
BOOL
DG_PACKET::DeleteIdlePackets(
long CurrentTime
)
/*++
Routine Description:
This fn scans the free packet list for very old packets and deletes them.
Arguments:
none
Return Value:
none
--*/
{
return FALSE;
}
DG_COMMON_CONNECTION::DG_COMMON_CONNECTION(
RPC_DATAGRAM_TRANSPORT *a_TransportInterface,
RPC_STATUS * pStatus
) :
Mutex (pStatus),
TimeStamp (0),
TransportInterface (a_TransportInterface),
ReferenceCount (0),
CurrentPduSize (a_TransportInterface->BasePduSize),
RemoteWindowSize (1),
RemoteDataUpdated (FALSE),
LowestActiveSequence(0),
LowestUnusedSequence(0),
ActiveSecurityContext(0)
{
}
DG_COMMON_CONNECTION::~DG_COMMON_CONNECTION()
{
delete ActiveSecurityContext;
}
RPC_STATUS
SendSecurePacket(
IN DG_ENDPOINT * SourceEndpoint,
IN DG_TRANSPORT_ADDRESS RemoteAddress,
IN UNALIGNED NCA_PACKET_HEADER *pHeader,
IN unsigned long DataOffset,
IN SECURITY_CONTEXT * SecurityContext
)
{
RPC_STATUS Status = RPC_S_OK;
unsigned TrailerLength = 0;
unsigned MaxTrailerSize = 0;
PDG_SECURITY_TRAILER pTrailer = 0;
if (SecurityContext && SecurityContext->AuthenticationLevel > RPC_C_AUTHN_LEVEL_NONE)
{
// Pad the stub data length to a multiple of 8, so the security
// trailer is properly aligned. OSF requires that the pad bytes
// be included in PacketBodyLen.
//
pHeader->SetPacketBodyLen(Align8(pHeader->GetPacketBodyLen()));
pHeader->AuthProto = (unsigned char) SecurityContext->AuthenticationService;
SECURITY_BUFFER_DESCRIPTOR BufferDescriptor;
SECURITY_BUFFER SecurityBuffers[5];
DCE_MSG_SECURITY_INFO MsgSecurityInfo;
BufferDescriptor.ulVersion = 0;
BufferDescriptor.cBuffers = 5;
BufferDescriptor.pBuffers = SecurityBuffers;
SecurityBuffers[0].BufferType = SECBUFFER_DATA | SECBUFFER_READONLY;
SecurityBuffers[0].pvBuffer = pHeader;
SecurityBuffers[0].cbBuffer = sizeof(NCA_PACKET_HEADER);
SecurityBuffers[1].BufferType = SECBUFFER_DATA;
SecurityBuffers[1].pvBuffer = pHeader->Data + DataOffset;
SecurityBuffers[1].cbBuffer = pHeader->GetPacketBodyLen();
if (SecurityContext->AuthenticationLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
{
SecurityBuffers[2].cbBuffer = (ULONG) Align(sizeof(DG_SECURITY_TRAILER), Align4(SecurityContext->BlockSize()));
SecurityBuffers[3].cbBuffer = SecurityContext->MaximumHeaderLength();
}
else
{
SecurityBuffers[2].cbBuffer = (ULONG) Align4(sizeof(DG_SECURITY_TRAILER));
SecurityBuffers[3].cbBuffer = SecurityContext->MaximumSignatureLength();
}
pTrailer = (PDG_SECURITY_TRAILER) _alloca(SecurityBuffers[2].cbBuffer + SecurityBuffers[3].cbBuffer);
SecurityBuffers[2].BufferType = SECBUFFER_DATA | SECBUFFER_READONLY;
SecurityBuffers[2].pvBuffer = pTrailer;
SecurityBuffers[3].BufferType = SECBUFFER_TOKEN;
SecurityBuffers[3].pvBuffer = (unsigned char *) pTrailer
+ SecurityBuffers[2].cbBuffer;
SecurityBuffers[4].BufferType = SECBUFFER_PKG_PARAMS | SECBUFFER_READONLY;
SecurityBuffers[4].pvBuffer = &MsgSecurityInfo;
SecurityBuffers[4].cbBuffer = sizeof(DCE_MSG_SECURITY_INFO);
MsgSecurityInfo.SendSequenceNumber = pHeader->GetFragmentNumber();
MsgSecurityInfo.ReceiveSequenceNumber = SecurityContext->AuthContextId;
MsgSecurityInfo.PacketType = ~0;
TrailerLength = SecurityBuffers[2].cbBuffer;
pTrailer->protection_level = (unsigned char) SecurityContext->AuthenticationLevel;
pTrailer->key_vers_num = (unsigned char) SecurityContext->AuthContextId;
Status = SecurityContext->SignOrSeal (
pHeader->SequenceNumber,
SecurityContext->AuthenticationLevel != RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
&BufferDescriptor );
ASSERT( SecurityBuffers[3].cbBuffer > 0 );
TrailerLength += SecurityBuffers[3].cbBuffer;
}
else
{
//
// Unsecure packet.
//
pHeader->AuthProto = 0;
}
if (RPC_S_OK == Status)
{
Status = SourceEndpoint->TransportInterface->Send(
&SourceEndpoint->TransportEndpoint,
RemoteAddress,
pHeader,
sizeof(NCA_PACKET_HEADER),
pHeader->Data + DataOffset,
pHeader->GetPacketBodyLen(),
pTrailer,
TrailerLength
);
}
return Status;
}
RPC_STATUS
VerifySecurePacket(
PDG_PACKET pPacket,
SECURITY_CONTEXT * pSecurityContext
)
{
RPC_STATUS Status = RPC_S_OK;
PDG_SECURITY_TRAILER pVerifier = (PDG_SECURITY_TRAILER)
(pPacket->Header.Data + pPacket->GetPacketBodyLen());
if (pSecurityContext->AuthenticationLevel < RPC_C_AUTHN_LEVEL_PKT)
{
return RPC_S_OK;
}
ASSERT(pVerifier->protection_level >= RPC_C_AUTHN_LEVEL_PKT);
ASSERT(pVerifier->protection_level <= RPC_C_AUTHN_LEVEL_PKT_PRIVACY);
SECURITY_BUFFER_DESCRIPTOR BufferDescriptor;
SECURITY_BUFFER SecurityBuffers[5];
DCE_MSG_SECURITY_INFO MsgSecurityInfo;
BufferDescriptor.ulVersion = 0;
BufferDescriptor.cBuffers = 5;
BufferDescriptor.pBuffers = SecurityBuffers;
SecurityBuffers[0].BufferType = SECBUFFER_DATA | SECBUFFER_READONLY;
SecurityBuffers[0].pvBuffer = &pPacket->Header;
SecurityBuffers[0].cbBuffer = sizeof(NCA_PACKET_HEADER);
SecurityBuffers[1].BufferType = SECBUFFER_DATA;
SecurityBuffers[1].pvBuffer = pPacket->Header.Data;
SecurityBuffers[1].cbBuffer = pPacket->GetPacketBodyLen();
SecurityBuffers[2].BufferType = SECBUFFER_DATA | SECBUFFER_READONLY;
SecurityBuffers[2].pvBuffer = pVerifier;
if (pVerifier->protection_level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
{
unsigned Alignment = Align4(pSecurityContext->BlockSize());
SecurityBuffers[2].cbBuffer = (ULONG) Align(sizeof(DG_SECURITY_TRAILER), Alignment);
SecurityBuffers[3].pvBuffer = AlignPtr(pVerifier + 1, Alignment);
}
else
{
SecurityBuffers[2].cbBuffer = (ULONG) Align4(sizeof(DG_SECURITY_TRAILER));
SecurityBuffers[3].pvBuffer = AlignPtr4(pVerifier + 1);
}
SecurityBuffers[3].BufferType = SECBUFFER_TOKEN;
SecurityBuffers[3].cbBuffer = pPacket->DataLength
- SecurityBuffers[1].cbBuffer
- SecurityBuffers[2].cbBuffer;
SecurityBuffers[4].BufferType = SECBUFFER_PKG_PARAMS | SECBUFFER_READONLY;
SecurityBuffers[4].pvBuffer = &MsgSecurityInfo;
SecurityBuffers[4].cbBuffer = sizeof(DCE_MSG_SECURITY_INFO);
MsgSecurityInfo.SendSequenceNumber = pPacket->GetFragmentNumber();
MsgSecurityInfo.ReceiveSequenceNumber = pSecurityContext->AuthContextId;
MsgSecurityInfo.PacketType = ~0;
//
// If the packet came from a big-endian machine, we must restore
// the header to its original condition or the checksum will fail.
//
ByteSwapPacketHeaderIfNecessary(pPacket);
Status = pSecurityContext->VerifyOrUnseal(
pPacket->Header.SequenceNumber,
pVerifier->protection_level != RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
&BufferDescriptor
);
//
// Gotta re-swap the header so we can still look at its fields.
//
ByteSwapPacketHeaderIfNecessary(pPacket);
if (RPC_S_OK != Status)
{
#ifdef DEBUGRPC
DbgPrint("dg rpc: %lx: pkt %lx type %lx has bad security info (error 0x%lx)\n",
GetCurrentProcessId(), pPacket, pPacket->Header.PacketType, Status);
#endif
ASSERT(Status == RPC_S_ACCESS_DENIED ||
Status == ERROR_SHUTDOWN_IN_PROGRESS ||
Status == ERROR_PASSWORD_MUST_CHANGE ||
Status == ERROR_PASSWORD_EXPIRED ||
Status == ERROR_ACCOUNT_DISABLED ||
Status == ERROR_INVALID_LOGON_HOURS);
}
return(Status);
}
BOOL
DG_PickleEEInfoIntoPacket (
IN DG_PACKET * Packet,
IN size_t PickleStartOffset
)
/*++
Function Name: PickeEEInfoIntoPacket
Parameters:
PickleStartOffset - the offset in bytes where the pickling starts
pHeader - pointer to the packet to fill
Description:
Checks for EEInfo on the thread, trims the EEInfo to Packet->MaxDataLength,
and pickles the EEInfo starting from PickleStartOffset.
Returns:
TRUE if EEInfo was pickled. FALSE if not.
--*/
{
BOOL fEEInfoPresent = FALSE;
ExtendedErrorInfo *EEInfo;
RPC_STATUS RpcStatus;
size_t CurrentPacketSize;
EEInfo = RpcpGetEEInfo();
if (EEInfo)
{
AddComputerNameToChain(EEInfo);
TrimEEInfoToLength (Packet->MaxDataLength, &CurrentPacketSize);
if (CurrentPacketSize != 0)
{
CurrentPacketSize += PickleStartOffset;
ASSERT(IsBufferAligned(Packet->Header.Data + PickleStartOffset));
RpcpMemorySet(Packet->Header.Data, 0, CurrentPacketSize);
RpcStatus = PickleEEInfo( EEInfo,
Packet->Header.Data + PickleStartOffset,
CurrentPacketSize - PickleStartOffset
);
if (RpcStatus == RPC_S_OK)
{
fEEInfoPresent = TRUE;
Packet->SetPacketBodyLen( CurrentPacketSize );
}
}
}
return fEEInfoPresent;
}
void
InitErrorPacket(
DG_PACKET * pPacket,
unsigned char PacketType,
RPC_STATUS RpcStatus
)
/*++
Routine Description:
Maps <ProcessStatus> to an NCA error code and sends
a FAULT or REJECT packet to the client, as appropriate.
Arguments:
pSendPacket - a packet to use, or zero if this fn should allocate one
ProcessStatus - NT RPC error code
Return Value:
none
--*/
{
NCA_PACKET_HEADER * pHeader = &pPacket->Header;
CleanupPacket(pHeader);
pHeader->PacketType = PacketType;
size_t FaultSize;
BOOL fEEInfoPresent = FALSE;
//
// This mapping distinguishes client-side shutdown from server-side shutdown.
//
if (RpcStatus == ERROR_SHUTDOWN_IN_PROGRESS)
{
if (PacketType == DG_REJECT)
{
RpcStatus = RPC_S_SERVER_UNAVAILABLE;
}
else
{
RpcStatus = ERROR_SERVER_SHUTDOWN_IN_PROGRESS;
}
}
else if (RpcStatus == RPC_P_CLIENT_SHUTDOWN_IN_PROGRESS)
{
RpcStatus = ERROR_SHUTDOWN_IN_PROGRESS;
}
if (g_fSendEEInfo)
{
fEEInfoPresent = DG_PickleEEInfoIntoPacket( pPacket, FIELD_OFFSET( EXTENDED_FAULT_BODY, EeInfo) );
}
if (fEEInfoPresent)
{
//
// Packet body length already set.
//
EXTENDED_FAULT_BODY * body = (EXTENDED_FAULT_BODY *) pHeader->Data;
body->NcaStatus = MapToNcaStatusCode(RpcStatus);
body->Magic = DG_EE_MAGIC_VALUE;
body->reserved1 = 0;
body->reserved2 = 0;
}
else
{
size_t XopenFaultSize = sizeof(unsigned long);
*(unsigned long *)(pHeader->Data) = MapToNcaStatusCode(RpcStatus);
pHeader->SetPacketBodyLen(XopenFaultSize);
}
}
Reference in New Issue Copy Permalink