#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; } // // 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(); // // 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. // 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); 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) { 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(); m_pHost->SWL_Periodic(); m_pHost->UP_Periodic(currentTime); m_pHost->CM_Periodic(); // // 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 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 (cbSrcDataSize <= DCS_MAX_PDC_COMPRESSABLE_PACKET) { // // Use PERSIST_PKZIP compression // compression = GCT_PERSIST_PKZIP; } else { // // 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 { pPacket->data.compressionType = (BYTE)compression; } // // 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 // { 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_SHAREDESKTOP_MSG: DCS_ShareDesktop(); break; case DCS_UNSHAREDESKTOP_MSG: DCS_UnshareDesktop(); 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; default: rc = DefWindowProc(hwnd, message, wParam, lParam); break; } DebugExitDWORD(DCSMainWndProc, rc); return(rc); } // // DCS_ShareDesktop() // void DCS_ShareDesktop(void) { DWORD dwAppID; DebugEntry(DCS_ShareDesktop); 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); g_asSession.pShare->HET_ShareDesktop(); DC_EXIT_POINT: DebugExitVOID(DCS_Share); } // // DCS_UnshareDesktop() // void DCS_UnshareDesktop(void) { DebugEntry(DCS_UnshareDesktop); if (!g_asSession.pShare || !g_asSession.pShare->m_pHost) { WARNING_OUT(("Failing unshare, nothing is shared by us")); DC_QUIT; } g_asSession.pShare->HET_UnshareAll(); 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); } // // SHP_ShareDesktop // BOOL SHP_ShareDesktop(void) { BOOL rc = FALSE; DebugEntry(SHP_ShareDesktop); if (g_asCanHost) { rc = PostMessage(g_asMainWindow, DCS_SHAREDESKTOP_MSG, 0, 0); } else { ERROR_OUT(("SHP_ShareDesktop: not able to share")); } DebugExitBOOL(SHP_ShareDesktop, rc); return(rc); } // // SHP_UnshareDesktop() // // 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_UnshareDesktop(void) { HRESULT hr = E_FAIL; DebugEntry(SHP_UnshareDesktop); if (g_asCanHost) { if (PostMessage(g_asMainWindow, DCS_UNSHAREDESKTOP_MSG, 0, 0)) { hr = S_OK; } } else { ERROR_OUT(("SHP_Unshare: not able to share")); } DebugExitHRESULT(SHP_UnshareDesktop, 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_asCanHost) { ERROR_OUT(("SHP_AllowControl failing, can't host")); 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_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_10: pStatus->Version = IAS_VERSION_10; break; default: ERROR_OUT(("Unknown version %d", pasT->cpcCaps.general.version)); break; } if (pasT->hetCount == HET_DESKTOPSHARED) pStatus->AreSharing = IAS_SHARING_DESKTOP; 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; } } // // 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); }