windows-xp/Source/XPSP1/NT/com/rpc/runtime/mtrt/dgpkt.cxx

//+-------------------------------------------------------------------------
//
//  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);
        }
}