#include "precomp.h"


//
// DCS.CPP
// Sharing main (init/term plus communication to/from ASMaster)
//
// Copyright(c) Microsoft 1997-
//

#define MLZ_FILE_ZONE  ZONE_CORE





//
// DCS_Init()
//
BOOL  DCS_Init(void)
{
    WNDCLASS    wc;
    BOOL        rc = FALSE;
    HDC         hdc;

    DebugEntry(DCS_Init);

    if (g_asOptions & AS_SERVICE)
    {
        WARNING_OUT(("AS is running as SERVICE"));
    }

    //
    // Register with the DC-Groupware Utility Services
    //
    if (!UT_InitTask(UTTASK_DCS, &g_putAS))
    {
        ERROR_OUT(( "Failed to init DCS task"));
        DC_QUIT;
    }
    UT_RegisterEvent(g_putAS, S20_UTEventProc, NULL, UT_PRIORITY_APPSHARING);


    //
    // Create the window
    //

    //
    // Register the main window class.
    //
    wc.style = 0;
    wc.lpfnWndProc = DCSMainWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = g_asInstance;
    wc.hIcon   = NULL;
    wc.hCursor = NULL;
    wc.hbrBackground = NULL;
    wc.lpszMenuName =  NULL;
    wc.lpszClassName = DCS_MAIN_WINDOW_CLASS;

    if (!RegisterClass(&wc))
    {
        ERROR_OUT(("DCS_Init: couldn't register main window class"));
        DC_QUIT;
    }

    //
    // Create the main window.
    //
    // We make the window topmost so that it is sent the WM_QUERYENDSESSION
    // message before any other (non-topmost) windows.  This lets us
    // prevent the session from closing down if we are still in a share.
    //
    g_asMainWindow = CreateWindowEx(
           WS_EX_TOPMOST,                // Make the window topmost
           DCS_MAIN_WINDOW_CLASS,        // See RegisterClass() call.
           NULL,                         // Text for window title bar.
           0,                            // Invisible.
           0,                            // Default horizontal position.
           0,                            // Default vertical position.
           200,                          // Default width.
           100,                          // Default height.
           NULL,                         // Overlapped windows have no parent.
           NULL,                         // Use the window class menu.
           g_asInstance,
           NULL                          // Pointer not needed.
           );

    if (!g_asMainWindow)
    {
        ERROR_OUT(("DCS_Init: couldn't create main window"));
        DC_QUIT;
    }

    //
    // Add a global atom for identifying hosted windows with.
    //
    g_asHostProp = GlobalAddAtom(HET_ATOM_NAME);
    if (!g_asHostProp)
    {
        ERROR_OUT(("Failed to add global atom for hosting property"));
        DC_QUIT;
    }

    //
    // Check that display driver is loaded (if it isn't we can't host)
    //
    hdc = GetDC(NULL);
    g_usrScreenBPP = GetDeviceCaps(hdc, BITSPIXEL) *
        GetDeviceCaps(hdc, PLANES);
    g_usrPalettized = ((GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) != 0);
    ReleaseDC(NULL, hdc);

    g_usrCaptureBPP = g_usrScreenBPP;

    ASSERT(!g_asCanHost);
    ASSERT(!g_osiInitialized);
    ASSERT(!g_asSharedMemory);
    ASSERT(!g_poaData[0]);
    ASSERT(!g_poaData[1]);
    ASSERT(!g_lpimSharedData);
    ASSERT(!g_sbcEnabled);
    ASSERT(!g_asbcBitMasks[0]);
    ASSERT(!g_asbcBitMasks[1]);
    ASSERT(!g_asbcBitMasks[2]);

    OSI_Init();


    //
    // If we can't get hold of a pointer to shared IM vars, we are hosed.
    //
    if (!g_lpimSharedData)
    {
        ERROR_OUT(("Failed to get shared IM data"));
        DC_QUIT;
    }

    ASSERT(g_lpimSharedData->cbSize == sizeof(IM_SHARED_DATA));

    if (g_asOptions & AS_UNATTENDED)
    {
        // Let the input pieces (Win9x or NT) know we're in unattended mode
        g_lpimSharedData->imUnattended = TRUE;
    }

    //
    // Scheduler
    //
    if (!SCH_Init())
    {
        ERROR_OUT(("SCH Init failed"));
        DC_QUIT;
    }

    //
    // Hosting
    //
    if (!HET_Init())
    {
        ERROR_OUT(("HET Init failed"));
        DC_QUIT;
    }

    //
    // Viewing
    //
    if (!VIEW_Init())
    {
        ERROR_OUT(("VIEW Init failed"));
        DC_QUIT;
    }

    //
    // T.120 & T.128 Net
    //

    //
    // Initialize the network layer last of all.  This prevents us from
    // getting requests before we've fully initialized our components.
    //
    if (!S20_Init())
    {
        ERROR_OUT(("S20 Init failed"));
        DC_QUIT;

    }
    if (!SC_Init())
    {
        ERROR_OUT(("SC Init failed"));
        DC_QUIT;
    }

    //
    // We are now initialized.  Post a deferred message to get fonts.
    //
    PostMessage(g_asMainWindow, DCS_FINISH_INIT_MSG, 0, 0);

    // All modules have successfully initialised. Return success.
    // We are now ready to participate in sharing.
    //
    rc = TRUE;

DC_EXIT_POINT:
    DebugExitBOOL(DCS_Init, rc);
    return(rc);
}


//
// DCS_Term()
//
void  DCS_Term(void)
{
    DebugEntry(DCS_Term);

    //
    // Kill window.  Do this FIRST so that any attempts to send us requests
    // or notifications will fail.
    //
    if (g_asMainWindow)
    {
        DestroyWindow(g_asMainWindow);
        g_asMainWindow = NULL;
    }

    UnregisterClass(DCS_MAIN_WINDOW_CLASS, g_asInstance);


    //
    // Network layer - terminate this early because it will handle
    // termination in a call by generating approriate events.
    //
    S20_Term();
    SC_Term();

    //
    // Scheduler.
    //
    SCH_Term();

    //
    // Viewing
    //
    VIEW_Term();

    //
    // Hosting
    //
    HET_Term();

    //
    // Fonts
    //
    FH_Term();

    //
    // Terminate OSI
    //
    OSI_Term();

    //
    // Free our atom.
    //
    if (g_asHostProp)
    {
        GlobalDeleteAtom(g_asHostProp);
        g_asHostProp = 0;
    }

    //
    // Deregister from the Groupware Utility Services
    //
    if (g_putAS)
    {
        UT_TermTask(&g_putAS);
    }

    DebugExitVOID(DCS_Term);
}


//
// DCS_FinishInit()
//
// This does slow font enumeration, and then tries to join a call if one
// has started up.  Even if font enum fails, we can share/view shared, we
// just won't send text orders
//
void DCS_FinishInit(void)
{
    DebugEntry(DCS_FinishInit);

    //
    // Determine what fonts we have locally.
    // Done after the r11 caps field is filled in, since if we dont support
    // some of the r11 caps, then we can reduce the amount of work we do
    // when we get the font metrics etc.
    //
    g_cpcLocalCaps.orders.capsNumFonts = (TSHR_UINT16)FH_Init();

    DebugExitVOID(DCS_FinishInit);
}



//
// FUNCTION: DCS_PartyJoiningShare
//
BOOL ASShare::DCS_PartyJoiningShare(ASPerson * pasPerson)
{
    BOOL            rc = FALSE;
    UINT            iDict;

    DebugEntry(ASShare::DCS_PartyJoiningShare);

    ValidatePerson(pasPerson);

    //
    // Allocate dictionaries for GDC Persistent dictionary compression if
    // this person supports it.  We'll use them to decompress data
    // received from this person.  NOTE:  Win95 2.0 does not support
    // persistent pkzip.
    //
    if (pasPerson->cpcCaps.general.genCompressionType & GCT_PERSIST_PKZIP)
    {
        //
        // Allocate persistent dictionaries (outgoing if us, incoming if
        // others).
        //
        TRACE_OUT(( "Allocating receive dictionary set for [%d]", pasPerson->mcsID));

        pasPerson->adcsDict = new GDC_DICTIONARY[GDC_DICT_COUNT];
        if (!pasPerson->adcsDict)
        {
            ERROR_OUT(("Failed to allocate persistent dictionaries for [%d]", pasPerson->mcsID));
            DC_QUIT;
        }
        else
        {
            //
            // Initialize cbUsed to zero
            //
            for (iDict = 0; iDict < GDC_DICT_COUNT; iDict++)
            {
                pasPerson->adcsDict[iDict].cbUsed = 0;
            }
        }
    }

    rc = TRUE;

DC_EXIT_POINT:
    DebugExitBOOL(ASShare::DCS_PartyJoiningShare, rc);
    return(rc);
}



//
// FUNCTION: DCS_PartyLeftShare
//
void  ASShare::DCS_PartyLeftShare(ASPerson * pasPerson)
{
    DebugEntry(ASShare::DCS_PartyLeftShare);

    ValidatePerson(pasPerson);

    //
    // Free any dictionaries we allocated
    //
    if (pasPerson->adcsDict)
    {
        delete[] pasPerson->adcsDict;
        pasPerson->adcsDict = NULL;
    }

    DebugExitVOID(ASShare::DCS_PartyLeftShare);
}



//
// DCS_RecalcCaps()
//
// Called when someone joins or leaves share.
//
void  ASShare::DCS_RecalcCaps(BOOL fJoiner)
{
    ASPerson * pasT;

    DebugEntry(ASShare::DCS_RecalcCaps);

    //
    // The combined compression support is initialised to the local support
    //
    ValidatePerson(m_pasLocal);
    m_dcsCompressionSupport = m_pasLocal->cpcCaps.general.genCompressionType;
    m_dcsCompressionLevel   = m_pasLocal->cpcCaps.general.genCompressionLevel;

    //
    // Loop through the remotes
    //
    for (pasT = m_pasLocal->pasNext; pasT != NULL; pasT = pasT->pasNext)
    {
        ValidatePerson(pasT);

        m_dcsCompressionSupport &=
            pasT->cpcCaps.general.genCompressionType;

        m_dcsCompressionLevel = min(m_dcsCompressionLevel,
            pasT->cpcCaps.general.genCompressionLevel);
    }

    TRACE_OUT(("DCS Combined compression level %u, support %#x",
            m_dcsCompressionLevel,
            m_dcsCompressionSupport));

    DebugExitVOID(ASShare::DCS_RecalcCaps);
}


//
// SC_Periodic()
//
// The Scheduler runs a separate thread which is responsible for posting
// messages to our main thread, for which SC_Periodic() is the handler.
// Posted messages have the highest priority in GetMessage(), above input,
// paints, and timers.
//
// The Scheduler is in one of three states:
// asleep, normal or turbo.  When it is asleep, this function is not
// called.  When it is in normal mode, this function is called at least
// once, but the scheduler is a lazy guy, so will fall asleep again unless
// you keep prodding him.  In turbo mode this function is called repeatedly
// and rapidly, but only for a relatively short time, after which the
// scheduler falls back into normal mode, and from there falls asleep.
//
void  ASShare::SC_Periodic(void)
{
    UINT    currentTime;

    DebugEntry(ASShare::SC_Periodic);

    //
    // We must get the time accurately.
    //
    currentTime = GetTickCount();

    //
    // Dont do a lot of work if this is an immediate reschedule due to
    // multiple queued entries.  Most processors will achieve this in
    // less than 5 mS.
    //
    if ((currentTime - m_dcsLastScheduleTime) < 5)
    {
        WARNING_OUT(("Quit early"));
        DC_QUIT;
    }

    m_dcsLastScheduleTime = currentTime;

    //
    // Call the input manager event playback function frequently so that
    // we keep the input queue empty.  (Note that we do not want to just
    // dump the input queue into USER because we would lose all the
    // repeat keystroke packets we have so carefully sent across)
    // To trigger input we just use a 0 personid and NULL packet.
    //
    if ((currentTime - m_dcsLastIMTime) > DCS_IM_PERIOD)
    {
        m_dcsLastIMTime = currentTime;
        IM_ReceivedPacket(NULL, NULL);
    }

    //
    // There are calls which are made periodically but don't have any
    // dependencies.  First call the ones we want to be called fairly
    // frequently.
    //
    if ((currentTime - m_dcsLastFastMiscTime) > DCS_FAST_MISC_PERIOD )
    {
        m_dcsLastFastMiscTime = currentTime;

        OE_Periodic();
        HET_Periodic();
        CA_Periodic();
        IM_Periodic();
    }

    //
    // Only send updates if we're hosting, and have managed to tell everyone
    // we're hosting.
    //
    if (m_pHost && !m_hetRetrySendState)
    {
        UINT    swlRc = 0;
        BOOL    fetchedBounds = FALSE;

        m_pHost->CA_Periodic();

        //
        // See if we need to swap the buffers over.  Only swap if we have
        // sent all the data from the current orders.
        //
        if (m_pHost->OA_GetFirstListOrder() == NULL)
        {
            //
            // Get the current bounds from the driver.  This will fill in
            // the share core's copy of the bounds.
            //
            m_pHost->BA_FetchBounds();
            fetchedBounds = TRUE;

            //
            // Set up the new order list buffer
            //
            m_pHost->OA_ResetOrderList();

            //
            // Bounds data should be reset to a usable state by SDG once it
            // has finished with them, so we just need to swap the buffers
            // at this point.
            //
            SHM_SwitchReadBuffer();
        }

        //
        // In this high frequency code path we only send SWP info if it
        // is flagged as needed by the CBT hooks or if SWL determines a
        // send is required.  Only SWL knows if a send is required so
        // pass the CBT indication into SWL and let it do the
        // determination.
        //
        // The SWL window scan performs preemptable operations and we
        // must detect the occurrence of preemption otherwise we find
        // ourselves sending updates against an invalid window
        // structure.  Therefore we query OA and BA to see if any
        // updates have been accumulated in the interim.  We can tight
        // loop trying to get a good SWL list because we really don't
        // want to yield at this point - it is just that we cannot
        // prevent it sometimes.  (Sweeping through menus is a good way
        // to exercise this code.)
        //

        //
        // Synchronize the fast path data
        //
        SHM_SwitchFastBuffer();

        swlRc = m_pHost->SWL_Periodic();
        if (swlRc != SWL_RC_ERROR)
        {
            //
            // Only send this stuff if we were able to send the window list
            // packet.
            //
            m_pHost->AWC_Periodic();

            //
            // We've sent a window list and the current active window, now
            // send drawing updates.
            //
            m_pHost->UP_Periodic(currentTime);

            //
            // See if the cursor has changed image or position
            //
            m_pHost->CM_Periodic();
        }
        else
        {
            TRACE_OUT(("SWL_Periodic waiting for visibility count"));
        }

        //
        // If we got the bounds from the driver, we have to let the driver know
        // how much of the bounds remain to be sent.
        //
        if (fetchedBounds)
        {
            m_pHost->BA_ReturnBounds();
        }
    }

DC_EXIT_POINT:
    SCH_ContinueScheduling(SCH_MODE_NORMAL);

    DebugExitVOID(ASShare::SC_Periodic);
}



//
// DCS_CompressAndSendPacket()
//
#ifdef _DEBUG
UINT ASShare::DCS_CompressAndSendPacket
#else
void ASShare::DCS_CompressAndSendPacket
#endif // _DEBUG
(
    UINT            streamID,
    UINT_PTR        nodeID,
    PS20DATAPACKET  pPacket,
    UINT            packetLength
)
{
    UINT            cbSrcDataSize;
    UINT            cbDstDataSize;
    UINT            compression;
    BOOL            compressed;
    UINT            dictionary;

    DebugEntry(ASShare::DCS_CompressAndSendPacket);

    ASSERT(streamID >= SC_STREAM_LOW);
    ASSERT(streamID <= SC_STREAM_HIGH);

    ASSERT(!m_ascSynced[streamID-1]);
    ASSERT(!m_scfInSync);

    ASSERT(packetLength < TSHR_MAX_SEND_PKT);

    //
    // Decide which (if any) compression algorithm we are going to use to
    // try and compress this packet.
    //
    compression     = 0;
    cbSrcDataSize   = packetLength - sizeof(S20DATAPACKET);

    //
    // Is the data a compressable size?
    //
    if ((cbSrcDataSize >= DCS_MIN_COMPRESSABLE_PACKET) &&
        (!m_dcsLargePacketCompressionOnly ||
            (cbSrcDataSize >= DCS_MIN_FAST_COMPRESSABLE_PACKET)))
    {

        //
        // If all nodes have genCompressionLevel 1 or above and all nodes
        // support PERSIST_PKZIP we will use PERSIST_PKZIP (if we are
        // ready).
        //
        // Otherwise, if all nodes support PKZIP and the packet is larger
        // than a predefined minimum size we will use PKZIP.
        //
        // Otherwise, we don't compress
        //
        if ((m_dcsCompressionLevel >= 1) &&
            (m_dcsCompressionSupport & GCT_PERSIST_PKZIP) &&
            (cbSrcDataSize <= DCS_MAX_PDC_COMPRESSABLE_PACKET))
        {
            //
            // Use PERSIST_PKZIP compression
            //
            compression = GCT_PERSIST_PKZIP;
        }
        else if (m_dcsCompressionSupport & GCT_PKZIP)
        {
            //
            // Use PKZIP compression
            //
            compression = GCT_PKZIP;
        }
    }


    //
    // Compress the packet
    //
    compressed = FALSE;
    if (compression != 0)
    {
        PGDC_DICTIONARY pgdcSrc = NULL;

        //
        // We compress only the data and not the header of course
        //
        cbDstDataSize     = cbSrcDataSize;

        ASSERT(m_ascTmpBuffer != NULL);

        //
        // Compress the data following the packet header.
        //
        if (compression == GCT_PERSIST_PKZIP)
        {
            //
            // Figure out what dictionary to use for the stream priority
            //
            switch (streamID)
            {
                case PROT_STR_UPDATES:
                    dictionary = GDC_DICT_UPDATES;
                    break;

                case PROT_STR_MISC:
                    dictionary = GDC_DICT_MISC;
                    break;

                case PROT_STR_INPUT:
                    dictionary = GDC_DICT_INPUT;
                    break;
            }

            pgdcSrc = &m_pasLocal->adcsDict[dictionary];
        }

        compressed = GDC_Compress(pgdcSrc,  GDCCO_MAXCOMPRESSION,
            m_agdcWorkBuf, (LPBYTE)(pPacket + 1),
            cbSrcDataSize, m_ascTmpBuffer, &cbDstDataSize);

        if (compressed)
        {
            //
            // The data was successfully compressed, copy it back
            //
            ASSERT(cbDstDataSize <= cbSrcDataSize);
            memcpy((pPacket+1), m_ascTmpBuffer, cbDstDataSize);

            //
            // The data length include the data header
            //
            pPacket->dataLength = (TSHR_UINT16)(cbDstDataSize + sizeof(DATAPACKETHEADER));
            pPacket->data.compressedLength = pPacket->dataLength;

            packetLength = cbDstDataSize + sizeof(S20DATAPACKET);
        }
    }

    //
    // Update the packet header.
    //
    if (!compressed)
    {
        pPacket->data.compressionType = 0;
    }
    else
    {
        if (m_dcsCompressionLevel >= 1)
        {
            pPacket->data.compressionType = (BYTE)compression;
        }
        else
        {
            pPacket->data.compressionType = CT_OLD_COMPRESSED;
        }
    }

    //
    // Send the packet.
    //
    S20_SendDataPkt(streamID, nodeID, pPacket);

#ifdef _DEBUG
    DebugExitDWORD(ASShare::DCS_CompressAndSendPacket, packetLength);
    return(packetLength);
#else
    DebugExitVOID(ASShare::DCS_CompressAndSendPacket);
#endif // _DEBUG
}


//
// DCS_FlowControl()
//
// This is called back from our flow control code.  The parameter passed
// is the new bytes/second rate that data is flowing at.  We turn small
// packet compression off when the rate is large, it means we're on a
// fast link so there's no need to bog down the CPU compressing small
// packets.
//
void  ASShare::DCS_FlowControl
(
    UINT    DataBytesPerSecond
)
{
    DebugEntry(ASShare::DCS_FlowControl);

    if (DataBytesPerSecond < DCS_FAST_THRESHOLD)
    {
        //
        // Throughput is slow
        //
        if (m_dcsLargePacketCompressionOnly)
        {
            m_dcsLargePacketCompressionOnly = FALSE;
            TRACE_OUT(("DCS_FlowControl:  SLOW; compress small packets"));
        }
    }
    else
    {
        //
        // Throughput is fast
        //
        if (!m_dcsLargePacketCompressionOnly)
        {
            m_dcsLargePacketCompressionOnly = TRUE;
            TRACE_OUT(("DCS_FlowControl:  FAST; don't compress small packets"));
        }
    }

    DebugExitVOID(ASShare::DCS_FlowControl);
}



//
// DCS_SyncOutgoing() - see dcs.h
//
void ASShare::DCS_SyncOutgoing(void)
{
    DebugEntry(ASShare::DCS_SyncOutgoing);

    //
    // Reset the send compression dictionaries
    //
    if (m_pasLocal->cpcCaps.general.genCompressionType & GCT_PERSIST_PKZIP)
    {
        UINT    i;

        ASSERT(m_pasLocal->adcsDict);

        for (i = 0; i < GDC_DICT_COUNT; i++)
        {
            //
            // Somebody has joined or left.  We need to start over
            // and wipe out any saved data.
            //
            m_pasLocal->adcsDict[i].cbUsed = 0;
        }
    }

    DebugExitVOID(ASShare::DCS_SyncOutgoing);
}




//
// DCS_NotifyUI()
//
void DCS_NotifyUI
(
    UINT        eventID,
    UINT        parm1,
    UINT        parm2
)
{
    DebugEntry(DCS_NotifyUI);

    //
    // Post event to Front End
    //
    UT_PostEvent(g_putAS, g_putUI, 0, eventID, parm1, parm2);

    DebugExitVOID(DCS_NotifyUI);
}



//
// DCSLocalDesktopSizeChanged
//
// Routine called whenever the desktop size changes.
//
// Updates local desktop size stored in capabilities and informs all other
// machine in a share of the new size
//
void  DCSLocalDesktopSizeChanged(UINT width, UINT height)
{
    DebugEntry(DCSLocalDesktopSizeChanged);

    //
    // Check that the desktop has actually changed size
    //
    if ((g_cpcLocalCaps.screen.capsScreenHeight == height) &&
        (g_cpcLocalCaps.screen.capsScreenWidth == width))
    {
        TRACE_OUT(( "Desktop size has not changed!"));
        DC_QUIT;
    }

    //
    // Update the desktop size
    //
    g_cpcLocalCaps.screen.capsScreenWidth = (TSHR_UINT16)width;
    g_cpcLocalCaps.screen.capsScreenHeight = (TSHR_UINT16)height;

    if (g_asSession.pShare)
    {
        g_asSession.pShare->CPC_UpdatedCaps((PPROTCAPS)&g_cpcLocalCaps.screen);
    }

DC_EXIT_POINT:
    DebugExitVOID(DCSLocalDesktopSizeChanged);
}




//
// Main window message procedure.
//
LRESULT CALLBACK DCSMainWndProc
(
    HWND        hwnd,
    UINT        message,
    WPARAM      wParam,
    LPARAM      lParam
)
{
    LRESULT     rc = 0;

    DebugEntry(DCSMainWndProc);

    switch (message)
    {
        case DCS_FINISH_INIT_MSG:
        {
            DCS_FinishInit();
            break;
        }

        case DCS_PERIODIC_SCHEDULE_MSG:
        {
            if (g_asSession.pShare)
            {
                //
                // Call our periodic processing function if there's at least
                // another person in the share with us.
                //
                g_asSession.pShare->ValidatePerson(g_asSession.pShare->m_pasLocal);

                //
                // NOTE:
                // If we add record/playback capabilities, get rid of this
                // or change the check.  This prevents us from allocating,
                // composing, and sending packets to nowhere when we are
                // the only person in the share.
                //
                if (g_asSession.pShare->m_pasLocal->pasNext || g_asSession.pShare->m_scfViewSelf)
                {
                    g_asSession.pShare->SC_Periodic();
                }
            }

            //
            // Notify the Scheduler that we have processed the scheduling
            // message, which signals that another one can be sent (only
            // one is outstanding at a time).
            //
            SCH_SchedulingMessageProcessed();
        }
        break;

        case WM_ENDSESSION:
        {
            //
            // The wParam specifies whether the session is about to end.
            //
            if (wParam && !(g_asOptions & AS_SERVICE))
            {
                //
                // Windows is about to terminate (abruptly!).  Call our
                // termination functions now - before Windows shuts down
                // the hardware device drivers.
                //
                // We don't leave this job to the WEP because by the time
                // it gets called the hardware device drivers have been
                // shut down and some of the calls we make then fail (e.g.
                // timeEndPeriod requires TIMER.DRV).
                //
                DCS_Term();
            }
        }
        break;

        case WM_CLOSE:
        {
            ERROR_OUT(("DCS window received WM_CLOSE, this should never happen"));
        }
        break;

        case WM_PALETTECHANGED:
        case WM_PALETTEISCHANGING:
        {
            //
            // Win95 patches the Palette DDIs which are more accurate,
            // so only key off this message for NT.
            //
            if (!g_asWin95 && g_asSharedMemory)
            {
                g_asSharedMemory->pmPaletteChanged = TRUE;
            }
        }
        break;

        case WM_DISPLAYCHANGE:
        {
            //
            // The desktop size is changing - we are passed the new size.
            //
            DCSLocalDesktopSizeChanged(LOWORD(lParam),
                                       HIWORD(lParam));
        }
        break;

        case WM_SETTINGCHANGE:
        case WM_USERCHANGED:
            if (g_asSession.pShare && g_asSession.pShare->m_pHost)
            {
                WARNING_OUT(("AS: Reset effects on %s", (message == WM_SETTINGCHANGE)
                    ? "SETTINGCHANGE" : "USERCHANGE"));
                HET_SetGUIEffects(FALSE, &g_asSession.pShare->m_pHost->m_hetEffects);
            }
            break;

        //
        // Private app sharing messages
        //
        case DCS_KILLSHARE_MSG:
            SC_EndShare();
            break;

        case DCS_SHARE_MSG:
            DCS_Share((HWND)lParam, (IAS_SHARE_TYPE)wParam);
            break;

        case DCS_UNSHARE_MSG:
            DCS_Unshare((HWND)lParam);
            break;

        case DCS_ALLOWCONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->CA_AllowControl((BOOL)wParam);
            }
            break;

        case DCS_TAKECONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->DCS_TakeControl((UINT)wParam);
            }
            break;

        case DCS_CANCELTAKECONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->DCS_CancelTakeControl((UINT)wParam);
            }
            break;

        case DCS_RELEASECONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->DCS_ReleaseControl((UINT)wParam);
            }
            break;

        case DCS_PASSCONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->DCS_PassControl((UINT)wParam, (UINT)lParam);
            }
            break;

        case DCS_GIVECONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->DCS_GiveControl((UINT)wParam);
            }
            break;

        case DCS_CANCELGIVECONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->DCS_CancelGiveControl((UINT)wParam);
            }
            break;

        case DCS_REVOKECONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->DCS_RevokeControl((UINT)wParam);
            }
            break;

        case DCS_PAUSECONTROL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->DCS_PauseControl((UINT)lParam, (BOOL)wParam != 0);
            }
            break;

        case DCS_NEWTOPLEVEL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->HET_HandleNewTopLevel((BOOL)wParam);
            }
            break;

        case DCS_RECOUNTTOPLEVEL_MSG:
            if (g_asSession.pShare)
            {
                g_asSession.pShare->HET_HandleRecountTopLevel((UINT)wParam);
            }
            break;

        default:
            rc = DefWindowProc(hwnd, message, wParam, lParam);
            break;
    }

    DebugExitDWORD(DCSMainWndProc, rc);
    return(rc);
}


//
// DCS_Share()
//
void DCS_Share(HWND hwnd, IAS_SHARE_TYPE uType)
{
    DWORD   dwAppID = 0;

    DebugEntry(DCS_Share);

    if (!g_asSession.pShare)
    {
        //
        // Create one.
        //
        if (!SC_CreateShare(S20_CREATE))
        {
            WARNING_OUT(("Failing share request; in wrong state"));
            DC_QUIT;
        }
    }

    ASSERT(g_asSession.pShare);

    //
    // Figure out what to do.
    //
    if (hwnd == ::GetDesktopWindow())
    {
        g_asSession.pShare->HET_ShareDesktop();
    }
    else
    {
        DWORD   dwThreadID;
        DWORD   dwProcessID;

        dwThreadID = GetWindowThreadProcessId(hwnd, &dwProcessID);
        if (!dwThreadID)
        {
            WARNING_OUT(("Failing share request, window %08lx is invalid", hwnd));
            DC_QUIT;
        }

        //
        // If caller didn't specify exactly what they want, figure it out
        //
        if (uType == IAS_SHARE_DEFAULT)
        {
            if (OSI_IsWOWWindow(hwnd))
                uType = IAS_SHARE_BYTHREAD;
            else
                uType = IAS_SHARE_BYPROCESS;
        }

        if (uType == IAS_SHARE_BYPROCESS)
            dwAppID = dwProcessID;
        else if (uType == IAS_SHARE_BYTHREAD)
            dwAppID = dwThreadID;
        else if (uType == IAS_SHARE_BYWINDOW)
            dwAppID = HandleToUlong(hwnd);

        if (IsIconic(hwnd))
            ShowWindow(hwnd, SW_SHOWNOACTIVATE);

        g_asSession.pShare->HET_ShareApp(uType, dwAppID);
    }

DC_EXIT_POINT:
    DebugExitVOID(DCS_Share);
}



//
// DCS_Unshare()
//
void DCS_Unshare(HWND hwnd)
{
    DebugEntry(DCS_Unshare);

    if (!g_asSession.pShare || !g_asSession.pShare->m_pHost)
    {
        WARNING_OUT(("Failing unshare, nothing is shared by us"));
        DC_QUIT;
    }

    if ((hwnd == HWND_BROADCAST) || (hwnd == ::GetDesktopWindow()))
    {
        // Unshare everything.
        g_asSession.pShare->HET_UnshareAll();
    }
    else
    {
        DWORD       idProcess;
        DWORD       idThread;
        DWORD       dwAppID;
        UINT        hostType;

        hostType = (UINT)HET_GetHosting(hwnd);
        if (!hostType)
        {
            WARNING_OUT(("Window %08lx is not shared", hwnd));
            DC_QUIT;
        }

        idThread = GetWindowThreadProcessId(hwnd, &idProcess);
        if (!idThread)
        {
            WARNING_OUT(("Window %08lx is gone", hwnd));
            DC_QUIT;
        }

        if (hostType & HET_HOSTED_BYPROCESS)
        {
            hostType = IAS_SHARE_BYPROCESS;
            dwAppID = idProcess;
        }
        else if (hostType & HET_HOSTED_BYTHREAD)
        {
            hostType = IAS_SHARE_BYTHREAD;
            dwAppID = idThread;
        }
        else
        {
            ASSERT(hostType & HET_HOSTED_BYWINDOW);
            hostType = IAS_SHARE_BYWINDOW;
            dwAppID = HandleToUlong(hwnd);
        }

        g_asSession.pShare->HET_UnshareApp(hostType, dwAppID);
    }

DC_EXIT_POINT:
    DebugExitVOID(DCS_Unshare);
}


//
// DCSGetPerson()
//
// Validates GCC ID passed in, returns non-null ASPerson * if all is cool.
//
ASPerson * ASShare::DCSGetPerson(UINT gccID, BOOL fNull)
{
    ASPerson * pasPerson = NULL;

    //
    // Special value?
    //
    if (!gccID)
    {
        if (fNull)
        {
            pasPerson = m_pasLocal->m_caInControlOf;
        }
    }
    else
    {
        pasPerson = SC_PersonFromGccID(gccID);
    }

    if (!pasPerson)
    {
        WARNING_OUT(("Person [%d] not in share", gccID));
    }
    else if (pasPerson == m_pasLocal)
    {
        ERROR_OUT(("Local person [%d] was passed in", gccID));
        pasPerson = NULL;
    }

    return(pasPerson);
}

//
// DCS_TakeControl()
//
void ASShare::DCS_TakeControl(UINT gccOf)
{
    ASPerson * pasHost;

    DebugEntry(ASShare::DCS_TakeControl);

    pasHost = DCSGetPerson(gccOf, FALSE);
    if (!pasHost)
    {
        WARNING_OUT(("DCS_TakeControl: ignoring, host [%d] not valid", gccOf));
        DC_QUIT;
    }

    CA_TakeControl(pasHost);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::DCS_TakeControl);
}



//
// DCS_CancelTakeControl()
//
void ASShare::DCS_CancelTakeControl(UINT gccOf)
{
    ASPerson * pasHost;

    DebugEntry(ASShare::DCS_CancelTakeControl);

    if (!gccOf)
    {
        pasHost = m_caWaitingForReplyFrom;
    }
    else
    {
        pasHost = DCSGetPerson(gccOf, FALSE);
    }

    if (!pasHost)
    {
        WARNING_OUT(("DCS_CancelTakeControl: Ignoring, host [%d] not valid", gccOf));
        DC_QUIT;
    }

    CA_CancelTakeControl(pasHost, TRUE);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::DCS_CancelTakeControl);
}


//
// DCS_ReleaseControl()
//
void ASShare::DCS_ReleaseControl(UINT gccOf)
{
    ASPerson * pasHost;

    DebugEntry(ASShare::DCS_ReleaseControl);

    //
    // Validate host
    //
    pasHost = DCSGetPerson(gccOf, TRUE);
    if (!pasHost)
    {
        WARNING_OUT(("DCS_ReleaseControl: ignoring, host [%d] not valid", gccOf));
        DC_QUIT;
    }

    CA_ReleaseControl(pasHost, TRUE);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::DCS_ReleaseControl);
}



//
// DCS_PassControl()
//
void ASShare::DCS_PassControl(UINT gccOf, UINT gccTo)
{
    ASPerson *  pasHost;
    ASPerson *  pasControllerNew;

    DebugEntry(ASShare::DCS_PassControl);

    //
    // Validate host
    //
    pasHost = DCSGetPerson(gccOf, TRUE);
    if (!pasHost)
    {
        WARNING_OUT(("DCS_PassControl: ignoring, host [%d] not valid", gccTo));
        DC_QUIT;
    }

    //
    // Validate new controller
    //
    pasControllerNew = DCSGetPerson(gccTo, FALSE);
    if (!pasControllerNew)
    {
        WARNING_OUT(("DCS_PassControl: ignoring, viewer [%d] not valid", gccTo));
        DC_QUIT;
    }

    if (pasControllerNew == pasHost)
    {
        ERROR_OUT(("DCS_PassControl: ignoring, pass of == pass to [%d]", pasControllerNew->mcsID));
        DC_QUIT;
    }

    CA_PassControl(pasHost, pasControllerNew);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::DCS_PassControl);
}



//
// DCS_GiveControl()
//
void ASShare::DCS_GiveControl(UINT gccTo)
{
    ASPerson * pasViewer;

    DebugEntry(ASShare::DCS_GiveControl);

    //
    // Validate viewer
    //
    pasViewer = DCSGetPerson(gccTo, FALSE);
    if (!pasViewer)
    {
        WARNING_OUT(("DCS_GiveControl: ignoring, viewer [%d] not valid", gccTo));
        DC_QUIT;
    }

    CA_GiveControl(pasViewer);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::DCS_GiveControl);
}



//
// DCS_CancelGiveControl()
//
void ASShare::DCS_CancelGiveControl(UINT gccTo)
{
    ASPerson * pasTo;

    DebugEntry(ASShare::DCS_CancelGiveControl);

    if (!gccTo)
    {
        pasTo = m_caWaitingForReplyFrom;
    }
    else
    {
        pasTo = DCSGetPerson(gccTo, FALSE);
    }

    if (!pasTo)
    {
        WARNING_OUT(("DCS_CancelGiveControl: Ignoring, person [%d] not valid", gccTo));
        DC_QUIT;
    }

    CA_CancelGiveControl(pasTo, TRUE);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::DCS_CancelGiveControl);
}



//
// DCS_RevokeControl()
//
void ASShare::DCS_RevokeControl(UINT gccController)
{
    ASPerson * pasController;

    DebugEntry(ASShare::DCS_RevokeControl);

    if (!gccController)
    {
        // Special value:  match whomever is controlling us
        pasController = m_pasLocal->m_caControlledBy;
    }
    else
    {
        pasController = DCSGetPerson(gccController, FALSE);
    }

    if (!pasController)
    {
        WARNING_OUT(("DCS_RevokeControl: ignoring, controller [%d] not valid", gccController));
        DC_QUIT;
    }

    CA_RevokeControl(pasController, TRUE);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::DCS_RevokeControl);
}




//
// DCS_PauseControl()
//
void ASShare::DCS_PauseControl(UINT gccOf, BOOL fPause)
{
    ASPerson *  pasControlledBy;

    DebugEntry(ASShare::DCS_PauseControl);

    if (!gccOf)
    {
        pasControlledBy = m_pasLocal->m_caControlledBy;
    }
    else
    {
        pasControlledBy = DCSGetPerson(gccOf, FALSE);
    }

    if (!pasControlledBy)
    {
        WARNING_OUT(("DCS_PauseControl: ignoring, controller [%d] not valid", gccOf));
        DC_QUIT;
    }

    CA_PauseControl(pasControlledBy, fPause, TRUE);

DC_EXIT_POINT:
    DebugExitVOID(ASShare::DCS_PauseControl);
}



//
// SHP_LaunchHostUI()
//
// Posts a message to start or activate the host UI.
//
HRESULT SHP_LaunchHostUI(void)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_LaunchHostUI);

    if (g_asSession.hwndHostUI &&
        PostMessage(g_asSession.hwndHostUI, HOST_MSG_OPEN, 0, 0))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_LaunchHostUI, hr);
    return(hr);
}


//
// SHP_Share
//
BOOL  SHP_Share
(
    HWND            hwnd,
    IAS_SHARE_TYPE  uType
)
{
    BOOL        rc = FALSE;

    DebugEntry(SHP_ShareApp);

    if (g_asSession.hwndHostUI)
    {
        rc = PostMessage(g_asMainWindow, DCS_SHARE_MSG, uType, (LPARAM)hwnd);
    }
    else
    {
        ERROR_OUT(("SHP_Share: not able to share"));
    }

    DebugExitBOOL(SHP_ShareApp, rc);
    return(rc);
}



//
// SHP_Unshare()
//
// For unsharing, we use a window.  The window has all the information
// we need to stop sharing already set in its host prop.
//
HRESULT SHP_Unshare(HWND hwnd)
{
    HRESULT     hr = E_FAIL;

    DebugEntry(SHP_Unshare);

    if (g_asSession.hwndHostUI)
    {
        if (PostMessage(g_asMainWindow, DCS_UNSHARE_MSG, 0, (LPARAM)hwnd))
        {
            hr = S_OK;
        }
    }
    else
    {
        ERROR_OUT(("SHP_Unshare: not able to share"));
    }

    DebugExitHRESULT(SHP_Unshare, hr);
    return(hr);
}



//
// SHP_TakeControl()
// Request to take control of a remote host.
//      PersonOf is the GCC id of the remote.
//
HRESULT  SHP_TakeControl(IAS_GCC_ID PersonOf)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_TakeControl);

    if (g_asMainWindow &&
        PostMessage(g_asMainWindow, DCS_TAKECONTROL_MSG, PersonOf, 0))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_TakeControl, hr);
    return(hr);
}



//
// SHP_CancelTakeControl()
// Cancel request to take control of a remote host.
//      PersonOf is the GCC id of the remote.
//
HRESULT  SHP_CancelTakeControl(IAS_GCC_ID PersonOf)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_CancelTakeControl);

    if (g_asMainWindow &&
        PostMessage(g_asMainWindow, DCS_CANCELTAKECONTROL_MSG, PersonOf, 0))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_CancelTakeControl, hr);
    return(hr);
}



//
// SHP_ReleaseControl()
// Release control of a remote host.
//      PersonOf is the GCC id of the remote we are currently controlling
//          and wish to stop.  Zero means "whomever" we are in control of
//          at the time.
//
HRESULT SHP_ReleaseControl(IAS_GCC_ID PersonOf)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_ReleaseControl);

    if (g_asMainWindow &&
        PostMessage(g_asMainWindow, DCS_RELEASECONTROL_MSG, PersonOf, 0))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_ReleaseControl, hr);
    return(hr);
}



//
// SHP_PassControl()
// Pass control of a remote to another prerson.
//      PersonOf is the GCC id of the remote we are currently controlling
//      PersonTo is the GCC id of the remote we wish to pass control to
//
HRESULT SHP_PassControl(IAS_GCC_ID PersonOf, IAS_GCC_ID PersonTo)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_PassControl);

    if (g_asMainWindow &&
        PostMessage(g_asMainWindow, DCS_PASSCONTROL_MSG, PersonOf, PersonTo))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_PassControl, hr);
    return(hr);
}


//
// SHP_AllowControl()
// Toggle the ability for remotes to control us (when we are sharing stuff)
//
HRESULT SHP_AllowControl(BOOL fAllowed)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_AllowControl);

    if (!g_asSession.hwndHostUI)
    {
        ERROR_OUT(("SHP_AllowControl failing, can't host"));
        DC_QUIT;

    }

    if (g_asPolicies & SHP_POLICY_NOCONTROL)
    {
        ERROR_OUT(("SHP_AllowControl failing. prevented by policy"));
        DC_QUIT;
    }

    if (PostMessage(g_asMainWindow, DCS_ALLOWCONTROL_MSG, fAllowed, 0))
    {
        hr = S_OK;
    }

DC_EXIT_POINT:
    DebugExitHRESULT(SHP_AllowControl, hr);
    return(hr);
}



//
// SHP_GiveControl()
//
// Give control of our shared stuff to a remote.
//
HRESULT SHP_GiveControl(IAS_GCC_ID PersonTo)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_GiveControl);

    if (g_asMainWindow &&
        PostMessage(g_asMainWindow, DCS_GIVECONTROL_MSG, PersonTo, 0))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_GiveControl, hr);
    return(hr);
}



//
// SHP_CancelGiveControl()
//
// Cancel giving control of our shared stuff to a remote.
//
HRESULT SHP_CancelGiveControl(IAS_GCC_ID PersonTo)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_CancelGiveControl);

    if (g_asMainWindow &&
        PostMessage(g_asMainWindow, DCS_CANCELGIVECONTROL_MSG, PersonTo, 0))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_CancelGiveControl, hr);
    return(hr);
}





//
// SHP_RevokeControl()
// Take control away from a remote who is in control of us.
//
// NOTE:
// SHP_AllowControl(FALSE) will of course revoke control if someone is
// in control of us at the time.
//
HRESULT SHP_RevokeControl(IAS_GCC_ID PersonTo)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_RevokeControl);

    if (g_asMainWindow &&
        PostMessage(g_asMainWindow, DCS_REVOKECONTROL_MSG, PersonTo, 0))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_RevokeControl, hr);
    return(hr);
}




//
// SHP_PauseControl()
// Pause or unpause control, when we are controlled by a remote
//
HRESULT SHP_PauseControl(IAS_GCC_ID PersonControlledBy, BOOL fPause)
{
    HRESULT hr = E_FAIL;

    DebugEntry(SHP_PauseControl);

    if (g_asMainWindow &&
        PostMessage(g_asMainWindow, DCS_PAUSECONTROL_MSG, fPause, PersonControlledBy))
    {
        hr = S_OK;
    }

    DebugExitHRESULT(SHP_PauseControl, hr);
    return(hr);
}



//
// SHP_GetPersonStatus()
//
HRESULT  SHP_GetPersonStatus(IAS_GCC_ID Person, IAS_PERSON_STATUS * pStatus)
{
    HRESULT     hr = E_FAIL;
    UINT        cbSize;

    DebugEntry(SHP_GetPersonStatus);

    UT_Lock(UTLOCK_AS);

    if (IsBadWritePtr(pStatus, sizeof(*pStatus)))
    {
        ERROR_OUT(("SHP_GetPersonStatus failing; IAS_PERSON_STATUS pointer is bogus"));
        DC_QUIT;
    }

    //
    // Check that size field is filled in properly
    //
    cbSize = pStatus->cbSize;
    if (cbSize != sizeof(*pStatus))
    {
        ERROR_OUT(("SHP_GetPersonStatus failing; cbSize field not right"));
        DC_QUIT;
    }

    //
    // First, clear the structure
    //
    ::ZeroMemory(pStatus, cbSize);
    pStatus->cbSize = cbSize;

    //
    // Is AS present?
    //
    if (!g_asMainWindow)
    {
        ERROR_OUT(("SHP_GetPersonStatus failing; AS not present"));
        DC_QUIT;
    }

    //
    // Are we in a share?
    //
    if (g_asSession.pShare)
    {
        ASPerson * pasT;

        //
        // Find this person
        //
        if (!Person)
        {
            Person = g_asSession.gccID;
        }

        for (pasT = g_asSession.pShare->m_pasLocal; pasT != NULL; pasT = pasT->pasNext)
        {
            if (pasT->cpcCaps.share.gccID == Person)
            {
                ASPerson * pTemp;

                //
                // Found it
                //
                pStatus->InShare = TRUE;

                switch (pasT->cpcCaps.general.version)
                {
                    case CAPS_VERSION_20:
                        pStatus->Version = IAS_VERSION_20;
                        break;

                    case CAPS_VERSION_30:
                        pStatus->Version = IAS_VERSION_30;
                        break;

                    default:
                        ERROR_OUT(("Unknown version %d", pasT->cpcCaps.general.version));
                        break;
                }

                if (pasT->hetCount == HET_DESKTOPSHARED)
                    pStatus->AreSharing = IAS_SHARING_DESKTOP;
                else if (pasT->hetCount)
                    pStatus->AreSharing = IAS_SHARING_APPLICATIONS;
                else
                    pStatus->AreSharing = IAS_SHARING_NOTHING;

                pStatus->Controllable = pasT->m_caAllowControl;

                //
                // We MUST assign to avoid faults.
                //
                pTemp = pasT->m_caInControlOf;
                if (pTemp)
                {
                    pStatus->InControlOf = pTemp->cpcCaps.share.gccID;
                }
                else
                {
                    pTemp = pasT->m_caControlledBy;
                    if (pTemp)
                    {
                        pStatus->ControlledBy = pTemp->cpcCaps.share.gccID;
                    }
                }

                pStatus->IsPaused = pasT->m_caControlPaused;

                //
                // We MUST assign to avoid faults.
                //
                pTemp = g_asSession.pShare->m_caWaitingForReplyFrom;
                if (pTemp)
                {
                    if (pasT == g_asSession.pShare->m_pasLocal)
                    {
                        //
                        // We have an outstanding request to this dude.
                        //
                        switch (g_asSession.pShare->m_caWaitingForReplyMsg)
                        {
                            case CA_REPLY_REQUEST_TAKECONTROL:
                                pStatus->InControlOfPending = pTemp->cpcCaps.share.gccID;
                                break;

                            case CA_REPLY_REQUEST_GIVECONTROL:
                                pStatus->ControlledByPending = pTemp->cpcCaps.share.gccID;
                                break;
                        }
                    }
                    else if (pasT == pTemp)
                    {
                        //
                        // This dude has an outstanding request from us.
                        //
                        switch (g_asSession.pShare->m_caWaitingForReplyMsg)
                        {
                            case CA_REPLY_REQUEST_TAKECONTROL:
                                pStatus->ControlledByPending = g_asSession.pShare->m_pasLocal->cpcCaps.share.gccID;
                                break;

                            case CA_REPLY_REQUEST_GIVECONTROL:
                                pStatus->InControlOfPending = g_asSession.pShare->m_pasLocal->cpcCaps.share.gccID;
                                break;
                        }
                    }
                }

                break;
            }
        }
    }

    hr = S_OK;

DC_EXIT_POINT:
    UT_Unlock(UTLOCK_AS);
    DebugExitHRESULT(SHP_GetPersonStatus, hr);
    return(hr);
}