--- /dev/null
+#include "stdafx.h"
+
+namespace MSTSCLib
+{
+#include "mstsclib_h.h"
+};
+
+namespace MSTSCLib_Redist
+{
+// extremely ew, but actually the cleanest way to import the alternate UUIDs
+#include "mstsclib_redist_i.c"
+};
+
+#include "rdesktop/rdesktop.h"
+#include "rdesktop/proto.h"
+
+namespace
+{
+#ifdef _MSC_VER
+extern "C" char __ImageBase;
+#endif
+
+HMODULE GetCurrentModule()
+{
+ return reinterpret_cast<HMODULE>(&__ImageBase);
+}
+
+}
+
+namespace
+{
+
+LONG g_moduleRefCount = 0;
+
+void lockServer()
+{
+ InterlockedIncrement(&g_moduleRefCount);
+}
+
+void unlockServer()
+{
+ InterlockedDecrement(&g_moduleRefCount);
+}
+
+bool canUnloadServer()
+{
+ return g_moduleRefCount == 0;
+}
+
+}
+
+namespace
+{
+
+void FreeLpsz(LPSTR lpsz)
+{
+ if(lpsz)
+ delete[] lpsz;
+}
+
+LPSTR AllocLpsz(const CHAR * lpsz, size_t cb)
+{
+ LPSTR lpszNew = new CHAR[cb + 1];
+
+ if(lpszNew == NULL)
+ return NULL;
+
+ CopyMemory(lpszNew, lpsz, cb);
+ lpszNew[cb] = 0;
+
+ return lpszNew;
+}
+
+LPSTR AllocLpsz(const WCHAR * lpwsz, int cchIn)
+{
+ int cch = WideCharToMultiByte(CP_ACP, 0, lpwsz, cchIn, NULL, 0, NULL, NULL);
+
+ if(cch <= 0)
+ return NULL;
+
+ LPSTR lpsz = new CHAR[cch];
+
+ if(lpsz == NULL)
+ return NULL;
+
+ cch = WideCharToMultiByte(CP_ACP, 0, lpwsz, cchIn, lpsz, cch, NULL, NULL);
+
+ if(cch <= 0)
+ {
+ FreeLpsz(lpsz);
+ return NULL;
+ }
+
+ return lpsz;
+}
+
+LPSTR BstrToLpsz(BSTR bstr)
+{
+ return AllocLpsz(bstr, SysStringLen(bstr));
+}
+
+BSTR LpszToBstr(LPSTR lpsz)
+{
+ int cch = MultiByteToWideChar(CP_ACP, 0, lpsz, -1, NULL, 0);
+
+ if(cch <= 0)
+ return NULL;
+
+ BSTR bstr = SysAllocStringLen(NULL, cch);
+
+ if(bstr == NULL)
+ return NULL;
+
+ cch = MultiByteToWideChar(CP_ACP, 0, lpsz, -1, bstr, cch);
+
+ if(cch <= 0)
+ {
+ SysFreeString(bstr);
+ return NULL;
+ }
+
+ return bstr;
+}
+
+}
+
+namespace
+{
+
+template<class T, class U> T aligndown(const T& X, const U& align)
+{
+ return X & ~(T(align) - 1);
+}
+
+template<class T, class U> T alignup(const T& X, const U& align)
+{
+ return aligndown(X + (align - 1), align);
+}
+
+/* Convert between bitmap formats */
+uint8 * win32_convert_scanlines(int width, int height, int bitcount, int fromalign, int toalign, const uint8 * data, uint8 ** buffer)
+{
+ // TBD: profile & optimize the most common cases
+ assert(width > 0);
+ assert(height);
+ assert(bitcount && bitcount <= 32);
+ assert(fromalign <= toalign);
+ assert(data);
+ assert(buffer);
+
+ bool flipped = height < 0;
+
+ if(flipped)
+ height = - height;
+
+ int bytesperrow = alignup(width * bitcount, 8) / 8;
+ int fromstride = alignup(bytesperrow, fromalign);
+ int tostride = alignup(bytesperrow, toalign);
+ assert(fromstride <= tostride);
+
+ int datasize = tostride * height;
+
+ uint8 * dibits = new uint8[datasize];
+
+ const uint8 * src = data;
+ uint8 * dest = dibits;
+
+ const int pad = tostride - fromstride;
+
+ assert(pad < 4);
+ __assume(pad < 4);
+
+ if(flipped)
+ {
+ dest += (height - 1) * tostride;
+ tostride = - tostride;
+ }
+
+ for(int i = 0; i < height; ++ i)
+ {
+ memcpy(dest, src, fromstride);
+ memset(dest + fromstride, 0, pad);
+ src += fromstride;
+ dest += tostride;
+ }
+
+ *buffer = dibits;
+ return dibits;
+}
+
+/* Creates bitmaps */
+HBITMAP win32_create_dib(LONG width, LONG height, WORD bitcount, const BYTE * data)
+{
+ struct b_
+ {
+ BITMAPINFO bmi;
+ RGBQUAD colormap[256 - ARRAYSIZE(RTL_FIELD_TYPE(BITMAPINFO, bmiColors))];
+ }
+ b;
+
+ b.bmi.bmiHeader.biSize = sizeof(b.bmi.bmiHeader);
+ b.bmi.bmiHeader.biWidth = width;
+ b.bmi.bmiHeader.biHeight = height;
+ b.bmi.bmiHeader.biPlanes = 1;
+ b.bmi.bmiHeader.biBitCount = bitcount;
+ b.bmi.bmiHeader.biCompression = BI_RGB;
+ b.bmi.bmiHeader.biSizeImage = 0;
+ b.bmi.bmiHeader.biXPelsPerMeter = 0;
+ b.bmi.bmiHeader.biYPelsPerMeter = 0;
+
+ if(bitcount > 8)
+ {
+ b.bmi.bmiHeader.biClrUsed = 0;
+ b.bmi.bmiHeader.biClrImportant = 0;
+ }
+ else
+ {
+ b.bmi.bmiHeader.biClrUsed = 2 << bitcount;
+ b.bmi.bmiHeader.biClrImportant = 2 << bitcount;
+
+ // TODO: palette
+ }
+
+ // FIXME: beyond ugly
+ HDC hdc = CreateCompatibleDC(NULL);
+
+ if(hdc == NULL)
+ return NULL;
+
+ HBITMAP hbm = CreateDIBitmap(hdc, &b.bmi.bmiHeader, CBM_INIT, data, &b.bmi, DIB_RGB_COLORS);
+
+ if(hbm == NULL)
+ error("CreateDIBitmap %dx%dx%d failed\n", width, height, bitcount);
+
+ DeleteDC(hdc);
+ return hbm;
+}
+
+/* Creates brushes */
+HBRUSH win32_create_brush(BRUSH * brush, COLORREF fgcolour)
+{
+ if(brush == NULL)
+ return (HBRUSH)GetStockObject(NULL_BRUSH);
+
+ switch(brush->style)
+ {
+ case BS_SOLID:
+ case BS_NULL:
+ case BS_HATCHED:
+ case BS_PATTERN:
+ case BS_PATTERN8X8:
+ break;
+
+ default:
+ return NULL;
+ }
+
+ switch(brush->style)
+ {
+ case BS_SOLID:
+ return CreateSolidBrush(fgcolour);
+
+ case BS_HATCHED:
+ return CreateHatchBrush(brush->pattern[0], fgcolour);
+
+ case BS_NULL:
+ return (HBRUSH)GetStockObject(NULL_BRUSH);
+
+ case BS_PATTERN:
+ case BS_PATTERN8X8:
+ {
+ uint16 pattern[8];
+
+ for(size_t i = 0; i < 8; ++ i)
+ pattern[i] = brush->pattern[i];
+
+ HBITMAP hpattern = CreateBitmap(8, 8, 1, 1, pattern);
+ HBRUSH hbr = CreatePatternBrush(hpattern);
+ DeleteObject(hpattern);
+ return hbr;
+ }
+
+ DEFAULT_UNREACHABLE;
+ }
+}
+};
+
+/*
+ "sealed" can improve optimizations by asserting a class cannot be derived
+ from, optimizing out accesses to the v-table from inside the class
+*/
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+#define SEALED_ sealed
+#else
+#define SEALED_
+#endif
+
+
+/* Class that implements the RDP client GUI */
+class RdpClientUI
+{
+public:
+ // TODO: pass the client settings relevant to the GUI here
+ HRESULT Initialize(HWND hwndParent)
+ {
+ // TODO: create the various windows
+ // TODO: create display window thread
+ // TODO: create input thread
+ return E_FAIL;
+ }
+
+public:
+ static BOOL Startup()
+ {
+ WNDCLASSEX wcexUI = { sizeof(wcexUI) };
+ WNDCLASSEX wcexConsole = { sizeof(wcexConsole) };
+ WNDCLASSEX wcexDisplay = { sizeof(wcexDisplay) };
+ WNDCLASSEX wcexInput = { sizeof(wcexInput) };
+
+ HBRUSH nullBrush = (HBRUSH)GetStockObject(HOLLOW_BRUSH);
+
+ wcexUI.lpfnWndProc = NULL; // TODO
+ wcexUI.hInstance = GetCurrentModule();
+ wcexUI.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wcexUI.hbrBackground = nullBrush;
+ wcexUI.lpszClassName = TEXT("MissTosca_UI");
+
+ wcexConsole.style = CS_VREDRAW | CS_HREDRAW;
+ wcexConsole.lpfnWndProc = NULL; // TODO
+ wcexConsole.hInstance = GetCurrentModule();
+ wcexConsole.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wcexConsole.hbrBackground = nullBrush;
+ wcexConsole.lpszClassName = TEXT("MissTosca_Console");
+
+ wcexDisplay.style = CS_VREDRAW | CS_HREDRAW;
+ wcexDisplay.lpfnWndProc = NULL; // TODO
+ wcexDisplay.hInstance = GetCurrentModule();
+ wcexDisplay.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wcexDisplay.hbrBackground = nullBrush;
+ wcexDisplay.lpszClassName = TEXT("MissTosca_Display");
+
+ wcexInput.style = CS_VREDRAW | CS_HREDRAW;
+ wcexInput.lpfnWndProc = NULL; // TODO
+ wcexInput.hInstance = GetCurrentModule();
+ wcexInput.hCursor = NULL;
+ wcexInput.hbrBackground = nullBrush;
+ wcexInput.lpszClassName = TEXT("MissTosca_Input");
+
+ return
+ RegisterClassEx(&wcexUI) &&
+ RegisterClassEx(&wcexConsole) &&
+ RegisterClassEx(&wcexDisplay) &&
+ RegisterClassEx(&wcexInput);
+ }
+
+ static void Shutdown()
+ {
+ // TODO
+ }
+
+ /*
+ This is the main UI window. It's the direct child of the control
+ window, it fills its whole extent and it contains the scrollbars.
+ When activated, it will move keyboard focus to the input window
+ */
+private:
+ HWND m_uiWindow;
+ LONG m_scrollHPos;
+ LONG m_scrollVPos;
+
+ LRESULT UIWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ // Keep the keyboard focus on the input window
+ case WM_ACTIVATE:
+ switch(LOWORD(wParam))
+ {
+ case WA_INACTIVE:
+ break;
+
+ case WA_ACTIVE:
+ case WA_CLICKACTIVE:
+ if(!HIWORD(wParam))
+ SetFocus(m_inputWindow);
+ }
+
+ return 0;
+
+ // Resized: rearrange children windows, adjust scrollbars
+ case WM_SIZE:
+ {
+ if(IsIconic(m_uiWindow))
+ break;
+
+ RECT rcClient;
+ GetWindowRect(m_uiWindow, &rcClient);
+
+ if(m_smartSizing)
+ {
+ // we are not supposed to maintain aspect ratio. Container has to do that
+ m_consoleX = 0;
+ m_consoleY = 0;
+ m_consoleWidth = rcClient.right;
+ m_consoleHeight = rcClient.bottom;
+ }
+ else
+ {
+ // center horizontally, no horizontal scrollbar
+ if(rcClient.right >= m_consoleWidth)
+ m_consoleX = (m_consoleWidth - rcClient.right) / 2;
+
+ // center vertically, no vertical scrollbar
+ if(rcClient.bottom >= m_consoleHeight)
+ m_consoleY = (m_consoleHeight - rcClient.right) / 2;
+ }
+
+ SCROLLINFO scroll = { sizeof(scroll), SIF_ALL, 0 };
+
+ // update the horizontal scrollbar
+ scroll.nMax = m_consoleWidth;
+ scroll.nPage = rcClient.right;
+ scroll.nPos = 0 - m_consoleX;
+ SetScrollInfo(m_uiWindow, SB_HORZ, &scroll, TRUE);
+
+ // update the vertical scrollbar
+ scroll.nMax = m_consoleHeight;
+ scroll.nPage = rcClient.bottom;
+ scroll.nPos = 0 - m_consoleY;
+ SetScrollInfo(m_uiWindow, SB_VERT, &scroll, TRUE);
+
+ // move/resize the console window
+ MoveWindow(m_consoleWindow, m_consoleX, m_consoleY, m_consoleWidth, m_consoleHeight, TRUE);
+ }
+
+ return 0;
+
+ case WM_HSCROLL:
+ {
+ SCROLLINFO scroll = { sizeof(scroll), SIF_TRACKPOS };
+ GetScrollInfo(m_uiWindow, SB_HORZ, &scroll);
+ m_consoleX = - scroll.nTrackPos;
+ MoveWindow(m_consoleWindow, m_consoleX, m_consoleY, m_consoleWidth, m_consoleHeight, TRUE);
+ }
+
+ return 0;
+
+ case WM_VSCROLL:
+ {
+ SCROLLINFO scroll = { sizeof(scroll), SIF_TRACKPOS };
+ GetScrollInfo(m_uiWindow, SB_VERT, &scroll);
+ m_consoleY = - scroll.nTrackPos;
+ MoveWindow(m_consoleWindow, m_consoleX, m_consoleY, m_consoleWidth, m_consoleHeight, TRUE);
+ }
+
+ return 0;
+
+ default:
+ break;
+ }
+
+ return DefWindowProc(m_uiWindow, uMsg, wParam, lParam);
+ }
+
+ /*
+ This is the full-screen title bar. It's displayed at the top of the
+ main UI window while in full-screen mode, and it contains two toolbars
+ with the pin, minimize, restore and close buttons
+ */
+ HWND m_fullScreenBarWindow;
+
+ /*
+ This is the console window. It has the same extent as the display on
+ the remote computer, or it fills the UI window in smart resizing mode,
+ and it contains the input and display windows
+ */
+private:
+ HWND m_consoleWindow;
+ LONG m_consoleX;
+ LONG m_consoleY;
+ LONG m_consoleWidth;
+ LONG m_consoleHeight;
+ bool m_smartSizing;
+
+ LRESULT ConsoleWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ case WM_SIZE:
+ {
+ RECT rcClient;
+ GetClientRect(m_consoleWindow, &rcClient);
+
+ MoveWindow(m_inputWindow, 0, 0, rcClient.right, rcClient.bottom, TRUE);
+ MoveWindow(m_displayWindow, 0, 0, rcClient.right, rcClient.bottom, TRUE);
+ }
+
+ return 0;
+
+ default:
+ break;
+ }
+
+ return DefWindowProc(m_consoleWindow, uMsg, wParam, lParam);
+ }
+
+ /*
+ This is the display window. It represents the virtual display of the
+ remote computer. It completely fills its parent, the console window,
+ and it runs in its own thread for performance reasons
+ */
+private:
+ HWND m_displayWindow;
+ LONG m_displayBufferWidth;
+ LONG m_displayBufferHeight;
+ HDC m_displayBuffer;
+ void * m_displayBufferRaw;
+ int m_displayBufferSave;
+ int m_displayBufferBitDepth;
+ int m_displayBufferByteDepth;
+ int m_displayBufferStride;
+ RECT m_displayBufferClip;
+ CRITICAL_SECTION m_displayBufferMutex;
+
+ LRESULT DisplayWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ case WM_DESTROY:
+ PostQuitMessage(0);
+ return 0;
+
+ case WM_PRINTCLIENT:
+ if(wParam == 0)
+ break;
+
+ case WM_PAINT:
+ {
+ HDC hdc = (HDC)wParam;
+
+ EnterCriticalSection(&m_displayBufferMutex);
+
+ if(hdc)
+ {
+ RECT rc;
+ GetClientRect(m_displayWindow, &rc);
+ BitBlt(hdc, 0, 0, rc.right, rc.bottom, m_displayBuffer, 0, 0, SRCCOPY);
+ }
+ else
+ {
+ PAINTSTRUCT ps;
+ hdc = BeginPaint(m_displayWindow, &ps);
+
+ if(!m_smartSizing)
+ {
+ BitBlt
+ (
+ hdc,
+ ps.rcPaint.left,
+ ps.rcPaint.top,
+ ps.rcPaint.right - ps.rcPaint.left,
+ ps.rcPaint.bottom - ps.rcPaint.top,
+ m_displayBuffer,
+ ps.rcPaint.left,
+ ps.rcPaint.top,
+ SRCCOPY
+ );
+ }
+ else
+ {
+ // bleh. There has to be a better way
+ SetStretchBltMode(hdc, HALFTONE);
+
+ StretchBlt
+ (
+ hdc,
+ 0,
+ 0,
+ m_consoleWidth,
+ m_consoleHeight,
+ m_displayBuffer,
+ 0,
+ 0,
+ m_displayBufferWidth,
+ m_displayBufferHeight,
+ SRCCOPY
+ );
+ }
+
+ EndPaint(m_displayWindow, &ps);
+ }
+
+ LeaveCriticalSection(&m_displayBufferMutex);
+ }
+
+ return 0;
+
+ default:
+ break;
+ }
+
+ return DefWindowProc(m_displayWindow, uMsg, wParam, lParam);
+ }
+
+ /* Screen repainting */
+ void Display_RepaintRect(const RECT * lprc)
+ {
+ if(m_smartSizing)
+ return Display_RepaintAll();
+
+ RECT rcDamage;
+ IntersectRect(&rcDamage, lprc, &m_displayBufferClip);
+ InvalidateRect(m_displayWindow, &rcDamage, FALSE);
+ }
+
+ void Display_RepaintArea(int x, int y, int cx, int cy)
+ {
+ if(m_smartSizing)
+ return Display_RepaintAll();
+
+ RECT rcDamage;
+ rcDamage.left = x;
+ rcDamage.top = y;
+ rcDamage.right = x + cx;
+ rcDamage.bottom = y + cy;
+ Display_RepaintRect(&rcDamage);
+ }
+
+ void Display_RepaintPolygon(POINT * point, int npoints, int linewidth)
+ {
+ if(m_smartSizing)
+ return Display_RepaintAll();
+
+ RECT rcDamage;
+
+ rcDamage.left = MAXLONG;
+ rcDamage.top = MAXLONG;
+ rcDamage.right = 0;
+ rcDamage.bottom = 0;
+
+ for(int i = 0; i < npoints; ++ i)
+ {
+ if(point[i].x < rcDamage.left)
+ rcDamage.left = point[i].x;
+
+ if(point[i].y < rcDamage.top)
+ rcDamage.top = point[i].y;
+
+ if(point[i].x > rcDamage.right)
+ rcDamage.right = point[i].x;
+
+ if(point[i].y > rcDamage.bottom)
+ rcDamage.bottom = point[i].y;
+ }
+
+ InflateRect(&rcDamage, linewidth, linewidth);
+ Display_RepaintRect(&rcDamage);
+ }
+
+ void Display_RepaintAll()
+ {
+ InvalidateRgn(m_displayWindow, NULL, FALSE);
+ }
+
+public:
+ void Display_SetClip(int x, int y, int cx, int cy)
+ {
+ m_displayBufferClip.left = x;
+ m_displayBufferClip.top = y;
+ m_displayBufferClip.right = x + cx + 1;
+ m_displayBufferClip.bottom = y + cy + 1;
+
+ HRGN hrgn = CreateRectRgnIndirect(&m_displayBufferClip);
+ SelectClipRgn(m_displayBuffer, hrgn);
+ DeleteObject(hrgn);
+ }
+
+ void Display_ResetClip()
+ {
+ m_displayBufferClip.left = 0;
+ m_displayBufferClip.top = 0;
+ m_displayBufferClip.right = m_displayBufferWidth;
+ m_displayBufferClip.bottom = m_displayBufferHeight;
+ SelectClipRgn(m_displayBuffer, NULL);
+ }
+
+ void Display_PaintBitmap(int x, int y, int cx, int cy, int width, int height, uint8 * data)
+ {
+ GdiFlush();
+
+ int fromstride = alignup(width * m_displayBufferByteDepth, 4);
+ int sizex = cx * m_displayBufferByteDepth;
+
+ const uint8 * src = data;
+
+ uint8 * dst =
+ (uint8 *)m_displayBufferRaw +
+ (m_displayBufferHeight - y - cy) * m_displayBufferStride +
+ x * m_displayBufferByteDepth;
+
+ for(int i = 0; i < cy; ++ i)
+ {
+ memcpy(dst, src, sizex);
+ src += fromstride;
+ dst += m_displayBufferStride;
+ }
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_DestBlt(uint8 opcode, int x, int y, int cx, int cy)
+ {
+ int dcsave = SaveDC(m_displayBuffer);
+ SelectObject(m_displayBuffer, GetStockObject(BLACK_BRUSH));
+ PatBlt(m_displayBuffer, x, y, cx, cy, MAKELONG(0, opcode));
+ RestoreDC(m_displayBuffer, dcsave);
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_PatBlt(uint8 opcode, int x, int y, int cx, int cy, BRUSH * brush, int bgcolour, int fgcolour)
+ {
+ HBRUSH hbr = win32_create_brush(brush, fgcolour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SetBkColor(m_displayBuffer, bgcolour);
+ SetTextColor(m_displayBuffer, fgcolour);
+ SetBrushOrgEx(m_displayBuffer, brush->xorigin, brush->yorigin, NULL);
+ SelectObject(m_displayBuffer, hbr);
+
+ PatBlt(m_displayBuffer, x, y, cx, cy, MAKELONG(0, opcode));
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ DeleteObject(hbr);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_ScreenBlt(uint8 opcode, int x, int y, int cx, int cy, int srcx, int srcy)
+ {
+ BitBlt(m_displayBuffer, x, y, cx, cy, m_displayBuffer, srcx, srcy, MAKELONG(0, opcode));
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_MemBlt(uint8 opcode, int x, int y, int cx, int cy, HBITMAP src, int srcx, int srcy)
+ {
+ HDC hdcSrc = CreateCompatibleDC(m_displayBuffer);
+ HGDIOBJ hOld = SelectObject(hdcSrc, src);
+
+ BitBlt(m_displayBuffer, x, y, cx, cy, hdcSrc, srcx, srcy, MAKELONG(0, opcode));
+
+ SelectObject(hdcSrc, hOld);
+ DeleteDC(hdcSrc);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_TriBlt(uint8 opcode, int x, int y, int cx, int cy, HBITMAP src, int srcx, int srcy, BRUSH * brush, int bgcolour, int fgcolour)
+ {
+ // TODO
+ HDC hdcSrc = CreateCompatibleDC(m_displayBuffer);
+ HGDIOBJ hOld = SelectObject(hdcSrc, src);
+
+ //SELECT_BRUSH(brush, bgcolour, fgcolour);
+
+ BitBlt(m_displayBuffer, x, y, cx, cy, hdcSrc, srcx, srcy, MAKELONG(0, opcode));
+
+ //RESET_BRUSH();
+
+ SelectObject(hdcSrc, hOld);
+ DeleteDC(hdcSrc);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_Line(uint8 opcode, int startx, int starty, int endx, int endy, PEN * pen)
+ {
+ HPEN hpen = CreatePen(pen->style, pen->width, pen->colour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SetROP2(m_displayBuffer, opcode);
+ SelectObject(m_displayBuffer, hpen);
+ MoveToEx(m_displayBuffer, startx, starty, NULL);
+
+ LineTo(m_displayBuffer, endx, endy);
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ DeleteObject(hpen);
+
+ RECT rcDamage;
+
+ if(startx < endx)
+ {
+ rcDamage.left = startx;
+ rcDamage.right = endx;
+ }
+ else
+ {
+ rcDamage.left = endx;
+ rcDamage.right = startx;
+ }
+
+ if(starty < endy)
+ {
+ rcDamage.top = starty;
+ rcDamage.bottom = endy;
+ }
+ else
+ {
+ rcDamage.top = endy;
+ rcDamage.bottom = starty;
+ }
+
+ InflateRect(&rcDamage, pen->width, pen->width);
+ Display_RepaintRect(&rcDamage);
+ }
+
+ void Display_Rect(int x, int y, int cx, int cy, int colour)
+ {
+ HBRUSH hbr = CreateSolidBrush(colour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SelectObject(m_displayBuffer, hbr);
+ SelectObject(m_displayBuffer, GetStockObject(NULL_PEN));
+
+ Rectangle(m_displayBuffer, x, y, x + cx + 1, y + cy + 1);
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ DeleteObject(hbr);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_Polygon(uint8 opcode, uint8 fillmode, POINT * point, int npoints, BRUSH * brush, int bgcolour, int fgcolour)
+ {
+ HBRUSH hbr = win32_create_brush(brush, fgcolour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SetBkColor(m_displayBuffer, bgcolour);
+ SetTextColor(m_displayBuffer, fgcolour);
+ SetPolyFillMode(m_displayBuffer, fillmode);
+ SelectObject(m_displayBuffer, hbr);
+
+ Polygon(m_displayBuffer, point, npoints);
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ Display_RepaintPolygon(point, npoints, 0);
+ }
+
+ void Display_Polyline(uint8 opcode, POINT * points, int npoints, PEN * pen)
+ {
+ POINT last = points[0];
+
+ for(int i = 1; i < npoints; ++ i)
+ {
+ points[i].x += last.x;
+ points[i].y += last.y;
+ last = points[i];
+ }
+
+ HPEN hpen = CreatePen(pen->style, pen->width, pen->colour);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ SetROP2(m_displayBuffer, opcode);
+ SelectObject(m_displayBuffer, hpen);
+
+ Polyline(m_displayBuffer, points, npoints);
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ DeleteObject(hpen);
+
+ Display_RepaintPolygon(points, npoints, pen->width);
+ }
+
+ void Display_Ellypse(uint8 opcode, uint8 fillmode, int x, int y, int cx, int cy, BRUSH * brush, int bgcolour, int fgcolour)
+ {
+ // TODO
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ // TBD: optimize text drawing
+ void Display_DrawGlyph(int mixmode, int x, int y, int cx, int cy, HGLYPH glyph, int srcx, int srcy, int bgcolour, int fgcolour)
+ {
+ HBITMAP hbmGlyph = (HBITMAP)glyph;
+ HDC hdcGlyph = CreateCompatibleDC(m_displayBuffer);
+ HGDIOBJ hOld = SelectObject(hdcGlyph, hbmGlyph);
+
+ int dcsave = SaveDC(m_displayBuffer);
+
+ switch(mixmode)
+ {
+ case MIX_TRANSPARENT:
+ {
+ /*
+ ROP is DSPDxax:
+ - where the glyph (S) is white, D is set to the foreground color (P)
+ - where the glyph (S) is black, D is left untouched
+
+ This paints a transparent glyph in the specified color
+ */
+ HBRUSH hbr = CreateSolidBrush(fgcolour);
+ SelectObject(m_displayBuffer, hbr);
+ BitBlt(m_displayBuffer, x, y, cx, cy, hdcGlyph, srcx, srcy, MAKELONG(0, 0xe2));
+ DeleteObject(hbr);
+ }
+
+ break;
+
+ case MIX_OPAQUE:
+ {
+ /* Curiously, glyphs are inverted (white-on-black) */
+ SetBkColor(m_displayBuffer, fgcolour);
+ SetTextColor(m_displayBuffer, bgcolour);
+ BitBlt(m_displayBuffer, x, y, cx, cy, hdcGlyph, srcx, srcy, SRCCOPY);
+ }
+
+ break;
+ }
+
+ RestoreDC(m_displayBuffer, dcsave);
+
+ SelectObject(hdcGlyph, hOld);
+ DeleteDC(hdcGlyph);
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+ void Display_DoGlyph(uint8 font, uint8 flags, int mixmode, int& x, int& y, int bgcolour, int fgcolour, const uint8 * ttext, int& idx)
+ {
+ FONTGLYPH * glyph;
+
+ glyph = cache_get_font(/*This*/NULL, font, ttext[idx]);
+
+ if(!(flags & TEXT2_IMPLICIT_X))
+ {
+ int xyoffset = ttext[++ idx];
+
+ if((xyoffset & 0x80))
+ {
+ if (flags & TEXT2_VERTICAL)
+ y += ttext[idx + 1] | (ttext[idx + 2] << 8);
+ else
+ x += ttext[idx + 1] | (ttext[idx + 2] << 8);
+
+ idx += 2;
+ }
+ else
+ {
+ if (flags & TEXT2_VERTICAL)
+ y += xyoffset;
+ else
+ x += xyoffset;
+ }
+ }
+
+ if(glyph)
+ {
+ Display_DrawGlyph
+ (
+ mixmode,
+ x + (short)glyph->offset,
+ y + (short)glyph->baseline,
+ glyph->width,
+ glyph->height,
+ glyph->pixmap,
+ 0,
+ 0,
+ bgcolour,
+ fgcolour
+ );
+
+ if(flags & TEXT2_IMPLICIT_X)
+ x += glyph->width;
+ }
+ }
+
+ void Display_DrawText
+ (
+ uint8 font,
+ uint8 flags,
+ uint8 opcode,
+ int mixmode,
+ int x,
+ int y,
+ int clipx,
+ int clipy,
+ int clipcx,
+ int clipcy,
+ int boxx,
+ int boxy,
+ int boxcx,
+ int boxcy,
+ BRUSH * brush,
+ int bgcolour,
+ int fgcolour,
+ uint8 * text,
+ uint8 length
+ )
+ {
+ int i, j;
+ DATABLOB *entry;
+
+ HBRUSH hbr = CreateSolidBrush(bgcolour);
+ HGDIOBJ holdbrush = SelectObject(m_displayBuffer, hbr);
+ HGDIOBJ holdpen = SelectObject(m_displayBuffer, GetStockObject(NULL_PEN));
+
+ if (boxcx > 1)
+ Rectangle(m_displayBuffer, boxx, boxy, boxx + boxcx + 1, boxy + boxcy + 1);
+ else if (mixmode == MIX_OPAQUE)
+ Rectangle(m_displayBuffer, clipx, clipy, clipx + clipcx + 1, clipy + clipcy + 1);
+
+ SelectObject(m_displayBuffer, holdpen);
+ SelectObject(m_displayBuffer, holdbrush);
+
+ DeleteObject(hbr);
+
+ if(boxcx > 1)
+ Display_RepaintArea(boxx, boxy, boxcx, boxcy);
+ else
+ Display_RepaintArea(clipx, clipy, clipcx, clipcy);
+
+ /* Paint text, character by character */
+ for (i = 0; i < length;)
+ {
+ switch (text[i])
+ {
+ case 0xff:
+ /* At least two bytes needs to follow */
+ if (i + 3 > length)
+ {
+ warning("Skipping short 0xff command:");
+ for (j = 0; j < length; j++)
+ fprintf(stderr, "%02x ", text[j]);
+ fprintf(stderr, "\n");
+ i = length = 0;
+ break;
+ }
+ cache_put_text(NULL /* TODO */, text[i + 1], text, text[i + 2]);
+ i += 3;
+ length -= i;
+ /* this will move pointer from start to first character after FF command */
+ text = &(text[i]);
+ i = 0;
+ break;
+
+ case 0xfe:
+ /* At least one byte needs to follow */
+ if (i + 2 > length)
+ {
+ warning("Skipping short 0xfe command:");
+ for (j = 0; j < length; j++)
+ fprintf(stderr, "%02x ", text[j]);
+ fprintf(stderr, "\n");
+ i = length = 0;
+ break;
+ }
+ entry = cache_get_text(/*This*/NULL, text[i + 1]);
+ if (entry->data != NULL)
+ {
+ if ((((uint8 *) (entry->data))[1] == 0)
+ && (!(flags & TEXT2_IMPLICIT_X)) && (i + 2 < length))
+ {
+ if (flags & TEXT2_VERTICAL)
+ y += text[i + 2];
+ else
+ x += text[i + 2];
+ }
+ for (j = 0; j < entry->size; j++)
+ Display_DoGlyph(font, flags, mixmode, x, y, bgcolour, fgcolour, ((uint8 *) (entry->data)), j);
+ }
+ if (i + 2 < length)
+ i += 3;
+ else
+ i += 2;
+ length -= i;
+ /* this will move pointer from start to first character after FE command */
+ text = &(text[i]);
+ i = 0;
+ break;
+
+ default:
+ Display_DoGlyph(font, flags, mixmode, x, y, bgcolour, fgcolour, text, i);
+ i++;
+ break;
+ }
+ }
+ }
+
+ void Display_SaveDesktop(uint32 offset, int x, int y, int cx, int cy)
+ {
+ GdiFlush();
+
+ uint8 * data =
+ (uint8 *)m_displayBufferRaw +
+ x * m_displayBufferByteDepth +
+ (m_displayBufferHeight - y - cy) * m_displayBufferStride;
+
+ cache_put_desktop
+ (
+ /*This*/NULL,
+ offset * m_displayBufferByteDepth,
+ cx,
+ cy,
+ m_displayBufferStride,
+ m_displayBufferByteDepth,
+ data
+ );
+ }
+
+ void Display_RestoreDesktop(uint32 offset, int x, int y, int cx, int cy)
+ {
+ int fromstride = cx * m_displayBufferByteDepth;
+
+ const uint8 * src = cache_get_desktop(/*This*/NULL, offset, cx, cy, m_displayBufferByteDepth);
+
+ uint8 * dst =
+ (uint8 *)m_displayBufferRaw +
+ x * m_displayBufferByteDepth +
+ (m_displayBufferHeight - y - cy) * m_displayBufferStride;
+
+ GdiFlush();
+
+ for(int i = 0; i < cy; ++ i)
+ {
+ memcpy(dst, src, fromstride);
+ src += fromstride;
+ dst += m_displayBufferStride;
+ }
+
+ Display_RepaintArea(x, y, cx, cy);
+ }
+
+
+ void Display_BeginUpdate()
+ {
+ EnterCriticalSection(&m_displayBufferMutex);
+ m_displayBufferSave = SaveDC(m_displayBuffer);
+ }
+
+ void Display_EndUpdate()
+ {
+ RestoreDC(m_displayBuffer, m_displayBufferSave);
+ LeaveCriticalSection(&m_displayBufferMutex);
+ }
+
+ /*
+ This is the input window. It receives the keyboard and mouse input from
+ the user, and it's the only window that can receive the keyboard focus.
+ It completely fills its parent, the console window, and it runs in its
+ own thread for performance reasons and because of technical reasons
+ involving keyboard hooks in full-screen mode
+ */
+ HWND m_inputWindow;
+ HCURSOR m_inputCursor;
+
+ LRESULT InputWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ case WM_DESTROY:
+ PostQuitMessage(0);
+ return 0;
+
+ /* Keyboard stuff */
+ // TODO: we need a good way to post output cross-thread
+ case WM_SYSKEYDOWN:
+ case WM_KEYDOWN:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_SCANCODE, RDP_KEYPRESS | (lparam & 0x1000000 ? KBD_FLAG_EXT : 0), LOBYTE(HIWORD(lparam)), 0);
+ break;
+
+ case WM_SYSKEYUP:
+ case WM_KEYUP:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_SCANCODE, RDP_KEYRELEASE | (lparam & 0x1000000 ? KBD_FLAG_EXT : 0), LOBYTE(HIWORD(lparam)), 0);
+ break;
+
+ /* Mouse stuff */
+ // Cursor shape
+ case WM_SETCURSOR:
+ if(LOWORD(lParam) == HTCLIENT)
+ {
+ SetCursor(m_inputCursor);
+ return TRUE;
+ }
+
+ break;
+
+ // Movement
+ case WM_MOUSEMOVE:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_MOVE, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ // Buttons
+ // TODO: X buttons
+ case WM_LBUTTONDOWN:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_RBUTTONDOWN:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_MBUTTONDOWN:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3 | MOUSE_FLAG_DOWN, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_LBUTTONUP:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON1, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_RBUTTONUP:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON2, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ case WM_MBUTTONUP:
+ //rdp_send_input(This, GetMessageTime(), RDP_INPUT_MOUSE, MOUSE_FLAG_BUTTON3, LOWORD(lparam), HIWORD(lparam));
+ break;
+
+ // Wheel
+ case WM_MOUSEWHEEL:
+ //mstsc_mousewheel(This, (SHORT)HIWORD(wparam), lparam);
+ break;
+ }
+
+ return DefWindowProc(m_inputWindow, uMsg, wParam, lParam);
+ }
+
+public:
+};
+
+#pragma warning(push)
+#pragma warning(disable: 4584)
+
+/* The ActiveX control */
+class RdpClient SEALED_:
+ /* COM basics */
+ public IUnknown,
+ public IDispatch,
+
+ /* ActiveX stuff */
+ public IConnectionPointContainer,
+ public IDataObject,
+ public IObjectSafety,
+ public IOleControl,
+ public IOleInPlaceActiveObject,
+ public IOleInPlaceObject,
+ public IOleObject,
+ public IOleWindow,
+ public IPersist,
+ public IPersistPropertyBag,
+ public IPersistStorage,
+ public IPersistStreamInit,
+ public IProvideClassInfo,
+ public IProvideClassInfo2,
+ public IQuickActivate,
+ public IViewObject,
+ public IViewObject2,
+
+ // NOTE: the original has a vestigial, non-functional implementation of this, which we omit
+ // ISpecifyPropertyPages
+
+ // Hidden interfaces, not available through QueryInterface
+ public IConnectionPoint,
+
+ /* RDP client interface */
+ public MSTSCLib::IMsRdpClient4,
+ public MSTSCLib::IMsRdpClientNonScriptable2
+
+ // NOTE: implemented by inner classes due to requiring distinct IDispatch implementations
+ // IMsRdpClientAdvancedSettings4
+ // IMsRdpClientSecuredSettings
+{
+private:
+ /* An endless amount of COM glue */
+ // Reference counting
+ LONG m_refCount;
+
+#ifdef _DEBUG
+ DWORD m_apartmentThreadId;
+
+ bool InsideApartment() const
+ {
+ return GetCurrentThreadId() == m_apartmentThreadId;
+ }
+#endif
+
+ // Aggregation support
+ IUnknown * m_punkOuter;
+
+ class RdpClientInner: public IUnknown
+ {
+ private:
+ RdpClient * Outer()
+ {
+ return InnerToOuter(this);
+ }
+
+ public:
+ virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ return Outer()->queryInterface(riid, ppvObject);
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::AddRef()
+ {
+ return Outer()->addRef();
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::Release()
+ {
+ return Outer()->release();
+ }
+
+ }
+ m_inner;
+
+ // Persistence support
+ CLSID m_classId;
+
+ // Late binding support
+ unsigned m_typeLibIndex;
+ ITypeLib * m_typeLib;
+ ITypeInfo * m_dispTypeInfo;
+
+ // Event sinks
+ size_t m_EventSinksCount;
+
+ union
+ {
+ MSTSCLib::IMsTscAxEvents * m_EventSinksStatic[1];
+ MSTSCLib::IMsTscAxEvents ** m_EventSinks;
+ };
+
+ // OLE control glue
+ HWND m_controlWindow;
+ IOleClientSite * m_clientSite;
+ IOleInPlaceSite * m_inPlaceSite;
+ IOleAdviseHolder * m_adviseHolder;
+ LONG m_freezeEvents;
+ bool m_uiActive;
+
+ // UrlMon security
+ DWORD m_SafetyOptions;
+
+ bool IsSafeForScripting() const
+ {
+ return m_SafetyOptions & INTERFACESAFE_FOR_UNTRUSTED_CALLER;
+ }
+
+ /* Glue to interface to rdesktop-core */
+ RdpClientUI * m_clientUI;
+ RDPCLIENT m_protocolState;
+ HANDLE m_protocolThread;
+ HANDLE m_protocolThreadWaitingReconnection;
+ bool m_reconnectAborted;
+ bool m_actuallyConnected;
+ bool m_loggedIn;
+
+ /* Properties */
+ // Storage fields
+ // NOTE: keep sorted by alignment (pointers and handles, integers, enumerations, booleans)
+ BSTR m_Domain;
+ BSTR m_UserName;
+ BSTR m_DisconnectedText;
+ BSTR m_ConnectingText;
+ BSTR m_FullScreenTitle;
+ BSTR m_StartProgram;
+ BSTR m_WorkDir;
+ BSTR m_ConnectedStatusText;
+ BSTR m_ClearTextPassword; // FIXME! dangerous, shouldn't store in cleartext!
+ BSTR m_RdpdrLocalPrintingDocName;
+ BSTR m_RdpdrClipCleanTempDirString;
+ BSTR m_RdpdrClipPasteInfoString;
+ BSTR m_KeyboardLayoutString;
+ LPSTR m_Server;
+ LPSTR m_LoadBalanceInfo;
+ // TODO: plugin DLLs
+ HWND m_UIParentWindowHandle;
+ long m_DesktopWidth;
+ long m_DesktopHeight;
+ long m_StartConnected;
+ long m_ColorDepth;
+ long m_KeyboardHookMode;
+ long m_AudioRedirectionMode;
+ long m_TransportType;
+ long m_SasSequence;
+ long m_RDPPort;
+ long m_HotKeyFullScreen;
+ long m_HotKeyAltEsc;
+ long m_HotKeyAltShiftTab;
+ long m_HotKeyAltSpace;
+ long m_HotKeyAltTab;
+ long m_HotKeyCtrlAltDel;
+ long m_HotKeyCtrlEsc;
+ long m_orderDrawThresold;
+ long m_BitmapCacheSize;
+ long m_BitmapVirtualCacheSize;
+ long m_NumBitmapCaches;
+ long m_brushSupportLevel;
+ long m_minInputSendInterval;
+ long m_InputEventsAtOnce;
+ long m_maxEventCount;
+ long m_keepAliveInternal;
+ long m_shutdownTimeout;
+ long m_overallConnectionTimeout;
+ long m_singleConnectionTimeout;
+ long m_MinutesToIdleTimeout;
+ long m_BitmapVirtualCache16BppSize;
+ long m_BitmapVirtualCache24BppSize;
+ long m_PerformanceFlags;
+ long m_MaxReconnectAttempts;
+ unsigned int m_AuthenticationLevel;
+
+ MSTSCLib::ExtendedDisconnectReasonCode m_ExtendedDisconnectReason;
+
+ bool m_Connected;
+ bool m_Compress;
+ bool m_BitmapPersistence;
+ bool m_allowBackgroundInput;
+ bool m_ContainerHandledFullScreen;
+ bool m_DisableRdpdr;
+ bool m_SecuredSettingsEnabled;
+ bool m_FullScreen;
+ bool m_AcceleratorPassthrough;
+ bool m_ShadowBitmap;
+ bool m_EncryptionEnabled;
+ bool m_DedicatedTerminal;
+ bool m_DisableCtrlAltDel;
+ bool m_EnableWindowsKey;
+ bool m_DoubleClickDetect;
+ bool m_MaximizeShell;
+ bool m_ScaleBitmapCachesByBpp;
+ bool m_CachePersistenceActive;
+ bool m_ConnectToServerConsole;
+ bool m_SmartSizing; // FIXME: this can be set while the control is connected
+ bool m_DisplayConnectionBar;
+ bool m_PinConnectionBar;
+ bool m_GrabFocusOnConnect;
+ bool m_RedirectDrives;
+ bool m_RedirectPrinters;
+ bool m_RedirectPorts;
+ bool m_RedirectSmartCards;
+ bool m_NotifyTSPublicKey;
+ bool m_CanAutoReconnect;
+ bool m_EnableAutoReconnect;
+ bool m_ConnectionBarShowMinimizeButton;
+ bool m_ConnectionBarShowRestoreButton;
+
+ // Generic getters/setters
+ HRESULT GetProperty(BSTR& prop, BSTR * retVal) const
+ {
+ assert(InsideApartment());
+
+ if(retVal == NULL)
+ return E_POINTER;
+
+ *retVal = SysAllocStringLen(prop, SysStringLen(prop));
+
+ if(*retVal == NULL)
+ return E_OUTOFMEMORY;
+
+ return S_OK;
+ }
+
+ HRESULT GetProperty(LPSTR& prop, BSTR * retVal) const
+ {
+ assert(InsideApartment());
+
+ if(retVal == NULL)
+ return E_POINTER;
+
+ *retVal = LpszToBstr(prop);
+
+ if(*retVal == NULL)
+ return E_OUTOFMEMORY;
+
+ return S_OK;
+ }
+
+ HRESULT SetProperty(BSTR& prop, BSTR newValue)
+ {
+ assert(InsideApartment());
+
+ if(m_Connected)
+ return E_FAIL;
+
+ SysFreeString(prop);
+
+ UINT len = SysStringLen(newValue);
+
+ if(len)
+ {
+ // no embedded NULs, please
+ if(len != lstrlenW(newValue))
+ return E_INVALIDARG;
+
+ prop = SysAllocStringLen(newValue, len);
+
+ if(prop == NULL)
+ return E_OUTOFMEMORY;
+ }
+ else
+ prop = NULL;
+
+ return S_OK;
+ }
+
+ HRESULT ReplaceProperty(BSTR& prop, BSTR newValue)
+ {
+ assert(InsideApartment());
+ assert((prop == NULL && newValue == NULL) || prop != newValue);
+
+ SysFreeString(prop);
+ prop = newValue;
+ return S_OK;
+ }
+
+ HRESULT SetProperty(LPSTR& prop, BSTR newValue)
+ {
+ assert(InsideApartment());
+
+ if(m_Connected)
+ return E_FAIL;
+
+ delete[] prop;
+
+ if(SysStringLen(newValue))
+ {
+ prop = BstrToLpsz(newValue);
+
+ if(prop == NULL)
+ return E_OUTOFMEMORY;
+ }
+ else
+ prop = NULL;
+
+ return S_OK;
+ }
+
+ HRESULT ReplaceProperty(LPSTR& prop, LPSTR newValue)
+ {
+ assert(InsideApartment());
+ assert((prop == NULL && newValue == NULL) || prop != newValue);
+
+ if(prop)
+ delete[] prop;
+
+ prop = newValue;
+ return S_OK;
+ }
+
+ template<class Type> HRESULT SetProperty(bool& prop, const Type& newValue)
+ {
+ assert(InsideApartment());
+
+ if(m_Connected)
+ return E_FAIL;
+
+ prop = !!newValue;
+ return S_OK;
+ }
+
+ template<class Type> HRESULT SetProperty(Type& prop, const Type& newValue)
+ {
+ assert(InsideApartment());
+
+ if(m_Connected)
+ return E_FAIL;
+
+ prop = newValue;
+ return S_OK;
+ }
+
+ template<class Type> HRESULT GetProperty(const bool& prop, Type * retVal) const
+ {
+ assert(InsideApartment());
+
+ if(retVal == NULL)
+ return E_POINTER;
+
+ *retVal = prop ? VARIANT_TRUE : VARIANT_FALSE;
+ return S_OK;
+ }
+
+ template<class Type> HRESULT GetProperty(const Type& prop, Type * retVal) const
+ {
+ assert(InsideApartment());
+
+ if(retVal == NULL)
+ return E_POINTER;
+
+ *retVal = prop;
+ return S_OK;
+ }
+
+ /* Events */
+ MSTSCLib::IMsTscAxEvents ** GetSinks() const
+ {
+ if(m_EventSinksCount > 1)
+ return m_EventSinks;
+ else
+ return const_cast<MSTSCLib::IMsTscAxEvents **>(m_EventSinksStatic);
+ }
+
+ // Event freezing
+ void UnfreezeEvents()
+ {
+ // Just in case
+ }
+
+ // Generic event riser & helpers
+ void InvokeSinks(DISPID eventId, VARIANTARG rgvarg[], unsigned int cArgs, VARIANTARG * retval)
+ {
+ assert(InsideApartment());
+
+ DISPPARAMS params;
+
+ params.rgvarg = rgvarg;
+ params.rgdispidNamedArgs = NULL;
+ params.cArgs = cArgs;
+ params.cNamedArgs = 0;
+
+ MSTSCLib::IMsTscAxEvents ** sinks = GetSinks();
+
+ for(size_t i = 0; i < m_EventSinksCount; ++ i)
+ sinks[i]->Invoke(eventId, IID_NULL, 0, DISPATCH_METHOD, ¶ms, retval, NULL, NULL);
+ }
+
+ typedef void (RdpClient::* AsyncEventCallback)
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg,
+ unsigned int cArgs,
+ VARIANTARG * retVal
+ );
+
+ void CleanupEventArgumentsCallback
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg,
+ unsigned int cArgs,
+ VARIANTARG * retVal
+ )
+ {
+ assert((rgvarg == NULL) == (cArgs == 0));
+
+ for(unsigned int i = 0; i < cArgs; ++ i)
+ VariantClear(&rgvarg[i]);
+
+ if(retVal)
+ VariantClear(retVal);
+ }
+
+ // synchronous call from inside the apartment that owns the object
+ void FireEventInsideApartment
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg = NULL,
+ unsigned int cArgs = 0,
+ VARIANTARG * retval = NULL,
+ AsyncEventCallback callback = NULL
+ )
+ {
+ assert(InsideApartment());
+
+ if(retval == NULL && callback)
+ {
+ VARIANTARG localRetval = { };
+ retval = &localRetval;
+ }
+
+ InvokeSinks(eventId, rgvarg, cArgs, retval);
+
+ if(callback)
+ (this->*callback)(eventId, rgvarg, cArgs, retval);
+ }
+
+ struct EventArguments
+ {
+ DISPID eventId;
+ VARIANTARG * rgvarg;
+ unsigned int cArgs;
+ VARIANTARG * retval;
+ AsyncEventCallback callback;
+ };
+
+ struct RedirectArguments
+ {
+ uint32 flags;
+ uint32 server_len;
+ wchar_t * server;
+ uint32 cookie_len;
+ char * cookie;
+ uint32 username_len;
+ wchar_t * username;
+ uint32 domain_len;
+ wchar_t * domain;
+ uint32 password_len;
+ wchar_t * password;
+ };
+
+ enum
+ {
+ RDPC_WM_ = WM_USER,
+ RDPC_WM_SYNC_EVENT,
+ RDPC_WM_ASYNC_EVENT,
+ RDPC_WM_DISCONNECT,
+ RDPC_WM_REQUEST_CLOSE,
+ RDPC_WM_REDIRECT,
+ };
+
+ static VOID CALLBACK DisconnectAPC(ULONG_PTR)
+ {
+ // no need to do anything. The interruption will be enough
+ }
+
+ bool HandleEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& result)
+ {
+ result = 0;
+
+ switch(uMsg)
+ {
+ /* Regular event to be dispatched to the container's sink */
+ case RDPC_WM_SYNC_EVENT:
+ assert(InSendMessage());
+
+ case RDPC_WM_ASYNC_EVENT:
+ {
+ const EventArguments * eventArgs = reinterpret_cast<EventArguments *>(lParam);
+ assert(eventArgs);
+
+ FireEventInsideApartment
+ (
+ eventArgs->eventId,
+ eventArgs->rgvarg,
+ eventArgs->cArgs,
+ eventArgs->retval,
+ eventArgs->callback
+ );
+
+ if(uMsg == RDPC_WM_ASYNC_EVENT)
+ delete eventArgs;
+ }
+
+ break;
+
+ /* The protocol thread is about to die: prepare for disconnection */
+ case RDPC_WM_DISCONNECT:
+ {
+ assert(m_Connected);
+ assert(InsideApartment());
+ assert(InSendMessage());
+
+ // Unblock the protocol thread and wait for it to terminate
+ ReplyMessage(0);
+ JoinProtocolThread();
+
+ // Finish disconnecting
+ PerformDisconnect(static_cast<long>(wParam));
+ }
+
+ break;
+
+ case RDPC_WM_REDIRECT:
+ {
+ assert(InSendMessage());
+ assert(lParam);
+ assert(m_Connected);
+ assert(m_protocolState.redirect);
+
+ RedirectArguments * redirectArgs = reinterpret_cast<RedirectArguments *>(lParam);
+
+ // BUGBUG: this is extremely messy and more prone to out-of-memory than it should be
+ LPSTR lpszNewServer = NULL;
+ LPSTR lpszNewCookie = NULL;
+ BSTR strNewUsername = NULL;
+ BSTR strNewDomain = NULL;
+ BSTR strNewPassword = NULL;
+ HRESULT hr = S_OK;
+
+ for(;;)
+ {
+ // Allocate the new properties
+ hr = E_OUTOFMEMORY;
+
+ // FIXME: convert the hostname to Punycode, not the ANSI codepage
+ lpszNewServer = AllocLpsz(redirectArgs->server, redirectArgs->server_len / sizeof(OLECHAR));
+
+ if(lpszNewServer == NULL && redirectArgs->server_len)
+ break;
+
+ lpszNewCookie = AllocLpsz(redirectArgs->cookie, redirectArgs->cookie_len);
+
+ if(lpszNewCookie == NULL && redirectArgs->cookie_len)
+ break;
+
+ strNewUsername = SysAllocStringLen(redirectArgs->username, redirectArgs->username_len / sizeof(OLECHAR));
+
+ if(strNewUsername == NULL && redirectArgs->username_len)
+ break;
+
+ strNewDomain = SysAllocStringLen(redirectArgs->domain, redirectArgs->domain_len / sizeof(OLECHAR));
+
+ if(strNewDomain == NULL && redirectArgs->domain_len)
+ break;
+
+ strNewPassword = SysAllocStringLen(redirectArgs->password, redirectArgs->password_len / sizeof(OLECHAR));
+
+ if(strNewPassword == NULL && redirectArgs->password_len)
+ break;
+
+ hr = S_OK;
+ break;
+ }
+
+ // Success
+ if(SUCCEEDED(hr))
+ {
+ // set the new properties
+ ReplaceProperty(m_Server, lpszNewServer);
+ ReplaceProperty(m_LoadBalanceInfo, lpszNewCookie);
+ ReplaceProperty(m_UserName, strNewUsername);
+ ReplaceProperty(m_Domain, strNewDomain);
+ ReplaceProperty(m_ClearTextPassword, strNewPassword);
+ }
+ // Failure
+ else
+ {
+ // free the buffers
+ FreeLpsz(lpszNewServer);
+ FreeLpsz(lpszNewCookie);
+ SysFreeString(strNewUsername);
+ SysFreeString(strNewDomain);
+ SysFreeString(strNewPassword);
+
+ // signal the error
+ m_protocolState.disconnect_reason = 262;
+ m_protocolState.redirect = False;
+ result = -1;
+ }
+ }
+
+ break;
+
+ // BUGBUG: this could potentially disconnect an unrelated connection established later...
+ case RDPC_WM_REQUEST_CLOSE:
+ {
+ assert(!InSendMessage());
+
+ if(m_Connected)
+ {
+ // Ask confirmation to the container in case we are logged in
+ if(m_loggedIn && !FireConfirmClose())
+ break;
+
+ // For reentrancy (OnConfirmClose could deviously call Disconnect)
+ if(m_protocolThread == NULL)
+ break;
+
+ // Terminate the protocol thread. It will fire the Disconnected event on exit
+ TerminateProtocolThread();
+ }
+ }
+
+ break;
+
+ default:
+ return false;
+ }
+
+ // If the calling thread is blocked, unblock it ASAP
+ if(InSendMessage())
+ ReplyMessage(result);
+
+ return true;
+ }
+
+ // synchronous call from outside the apartment
+ void FireEventOutsideApartment
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg = NULL,
+ unsigned int cArgs = 0,
+ VARIANTARG * retval = NULL,
+ AsyncEventCallback callback = NULL
+ )
+ {
+ assert(!InsideApartment());
+ EventArguments syncEvent = { eventId, rgvarg, cArgs, retval, callback };
+ SendMessage(m_controlWindow, RDPC_WM_SYNC_EVENT, 0, reinterpret_cast<LPARAM>(&syncEvent));
+ }
+
+ // asynchronous call from outside the apartment
+ HRESULT FireEventOutsideApartmentAsync
+ (
+ DISPID eventId,
+ VARIANTARG * rgvarg = NULL,
+ unsigned int cArgs = 0,
+ VARIANTARG * retval = NULL,
+ AsyncEventCallback callback = NULL
+ )
+ {
+ assert(!InsideApartment());
+
+ EventArguments * asyncEvent = new EventArguments();
+
+ if(asyncEvent == NULL)
+ return E_OUTOFMEMORY;
+
+ asyncEvent->eventId = eventId;
+ asyncEvent->rgvarg = rgvarg;
+ asyncEvent->cArgs = cArgs;
+ asyncEvent->retval = NULL;
+
+ if(!PostMessage(m_controlWindow, RDPC_WM_ASYNC_EVENT, 0, reinterpret_cast<LPARAM>(asyncEvent)))
+ {
+ delete asyncEvent;
+ return HRESULT_FROM_WIN32(GetLastError());
+ }
+
+ return S_OK;
+ }
+
+ // Specific events
+ void FireConnecting()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(1);
+ }
+
+ void FireConnected()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(2);
+ }
+
+ void FireLoginComplete()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(3);
+ }
+
+ void FireDisconnected(long reason)
+ {
+ // Source: protocol. Special handling
+ SendMessage(m_controlWindow, RDPC_WM_DISCONNECT, reason, 0);
+ }
+
+ void FireEnterFullScreenMode()
+ {
+ // Source: UI window
+ FireEventInsideApartment(5);
+ }
+
+ void FireLeaveFullScreenMode()
+ {
+ // Source: UI window
+ FireEventInsideApartment(6);
+ }
+
+ HRESULT FireChannelReceivedData(char (& chanName)[CHANNEL_NAME_LEN + 1], void * chanData, unsigned int chanDataSize)
+ {
+ // BUGBUG: what to do when we run out of memory?
+
+ OLECHAR wchanName[ARRAYSIZE(chanName)];
+ std::copy(chanName + 0, chanName + ARRAYSIZE(chanName), wchanName);
+
+ BSTR bstrChanName = SysAllocString(wchanName);
+
+ if(bstrChanName == NULL)
+ return E_OUTOFMEMORY;
+
+ BSTR bstrChanData = SysAllocStringByteLen(NULL, chanDataSize);
+
+ if(bstrChanData == NULL)
+ {
+ SysFreeString(bstrChanName);
+ return E_OUTOFMEMORY;
+ }
+
+ CopyMemory(bstrChanData, chanData, chanDataSize);
+
+ VARIANTARG args[2] = { };
+
+ args[1].vt = VT_BSTR;
+ args[1].bstrVal = bstrChanName;
+
+ args[0].vt = VT_BSTR;
+ args[0].bstrVal = bstrChanData;
+
+ // Source: protocol
+ HRESULT hr = FireEventOutsideApartmentAsync(7, args, ARRAYSIZE(args), NULL, &RdpClient::CleanupEventArgumentsCallback);
+
+ if(FAILED(hr))
+ CleanupEventArgumentsCallback(7, args, ARRAYSIZE(args), NULL);
+
+ return hr;
+ }
+
+ void FireRequestGoFullScreen()
+ {
+ // Source: UI window
+ FireEventInsideApartment(8);
+ }
+
+ void FireRequestLeaveFullScreen()
+ {
+ // Source: UI window
+ FireEventInsideApartment(9);
+ }
+
+ void FireFatalError(long errorCode)
+ {
+ VARIANTARG arg = { };
+
+ arg.vt = VT_I4;
+ arg.lVal = errorCode;
+
+ // Source: protocol
+ FireEventOutsideApartment(10, &arg, 1);
+ }
+
+ void FireFatalErrorFromApartment(long errorCode)
+ {
+ VARIANTARG arg = { };
+
+ arg.vt = VT_I4;
+ arg.lVal = errorCode;
+
+ // Source: control
+ FireEventInsideApartment(10, &arg, 1);
+ }
+
+ void FireWarning(long warningCode)
+ {
+ VARIANTARG arg = { };
+
+ arg.vt = VT_I4;
+ arg.lVal = warningCode;
+
+ // Source: protocol
+ FireEventOutsideApartment(11, &arg, 1);
+ }
+
+ void FireRemoteDesktopSizeChange(long width, long height)
+ {
+ VARIANTARG args[2] = { };
+
+ args[1].vt = VT_I4;
+ args[1].lVal = width;
+
+ args[0].vt = VT_I4;
+ args[0].lVal = height;
+
+ // Source: UI window
+ FireEventInsideApartment(12, args, ARRAYSIZE(args));
+ }
+
+ void FireIdleTimeoutNotification()
+ {
+ // Source: input thread
+ FireEventOutsideApartment(13);
+ }
+
+ void FireRequestContainerMinimize()
+ {
+ // Source: UI window
+ FireEventInsideApartment(14);
+ }
+
+ bool FireConfirmClose()
+ {
+ VARIANTARG retval = { };
+ VARIANT_BOOL allowClose = VARIANT_TRUE;
+
+ retval.vt = VT_BYREF | VT_BOOL;
+ retval.pboolVal = &allowClose;
+
+ // Source: control
+ FireEventInsideApartment(15, NULL, 0, &retval);
+
+ return allowClose != VARIANT_FALSE;
+ }
+
+ HRESULT FireReceivedTSPublicKey(void * publicKey, unsigned int publicKeyLength)
+ {
+ assert(m_Connected);
+
+ if(!m_NotifyTSPublicKey)
+ return S_OK;
+
+ BSTR bstrPublicKey = SysAllocStringByteLen(NULL, publicKeyLength);
+
+ if(bstrPublicKey == NULL)
+ return E_OUTOFMEMORY;
+
+ CopyMemory(bstrPublicKey, publicKey, publicKeyLength);
+
+ VARIANT_BOOL continueLogon = VARIANT_TRUE;
+ VARIANTARG arg = { };
+ VARIANTARG retval = { };
+
+ arg.vt = VT_BSTR;
+ arg.bstrVal = bstrPublicKey;
+
+ retval.vt = VT_BYREF | VT_BOOL;
+ retval.pboolVal = &continueLogon;
+
+ // Source: protocol
+ FireEventOutsideApartment(16, &arg, 1, &retval);
+
+ return continueLogon ? S_OK : S_FALSE;
+ }
+
+ LONG FireAutoReconnecting(long disconnectReason, long attemptCount)
+ {
+ LONG continueStatus = MSTSCLib::autoReconnectContinueAutomatic;
+ VARIANTARG args[2] = { };
+ VARIANTARG retval = { };
+
+ args[1].vt = VT_I4;
+ args[1].lVal = disconnectReason;
+
+ args[0].vt = VT_I4;
+ args[0].lVal = attemptCount;
+
+ retval.vt = VT_BYREF | VT_I4;
+ retval.plVal = &continueStatus;
+
+ // Source: protocol
+ FireEventOutsideApartment(17, args, ARRAYSIZE(args), &retval);
+
+ return continueStatus;
+ }
+
+ void FireAuthenticationWarningDisplayed()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(18);
+ }
+
+ void FireAuthenticationWarningDismissed()
+ {
+ // Source: protocol
+ FireEventOutsideApartment(19);
+ }
+
+ /* Actual IUnknown implementation */
+ HRESULT queryInterface(REFIID riid, void ** ppvObject)
+ {
+ IUnknown * pvObject = NULL;
+
+ using namespace MSTSCLib;
+
+ if(riid == IID_IUnknown)
+ pvObject = static_cast<IUnknown *>(&m_inner);
+ else if(riid == IID_IConnectionPointContainer)
+ pvObject = static_cast<IConnectionPointContainer *>(this);
+ else if(riid == IID_IDataObject)
+ pvObject = static_cast<IDataObject *>(this);
+ else if(riid == IID_IObjectSafety)
+ pvObject = static_cast<IObjectSafety *>(this);
+ else if(riid == IID_IOleControl)
+ pvObject = static_cast<IOleControl *>(this);
+ else if(riid == IID_IOleInPlaceActiveObject)
+ pvObject = static_cast<IOleInPlaceActiveObject *>(this);
+ else if(riid == IID_IOleInPlaceObject)
+ pvObject = static_cast<IOleInPlaceObject *>(this);
+ else if(riid == IID_IOleObject)
+ pvObject = static_cast<IOleObject *>(this);
+ else if(riid == IID_IOleWindow)
+ pvObject = static_cast<IOleWindow *>(this);
+ else if(riid == IID_IPersist)
+ pvObject = static_cast<IPersist *>(this);
+ else if(riid == IID_IPersistPropertyBag)
+ pvObject = static_cast<IPersistPropertyBag *>(this);
+ else if(riid == IID_IPersistStorage)
+ pvObject = static_cast<IPersistStorage *>(this);
+ else if(riid == IID_IPersistStreamInit)
+ pvObject = static_cast<IPersistStreamInit *>(this);
+ else if(riid == IID_IQuickActivate)
+ pvObject = static_cast<IQuickActivate *>(this);
+ else if(riid == IID_IViewObject)
+ pvObject = static_cast<IViewObject *>(this);
+ else if(riid == IID_IViewObject2)
+ pvObject = static_cast<IViewObject2 *>(this);
+ else if(riid == IID_IMsTscAx || riid == MSTSCLib_Redist::IID_IMsTscAx)
+ pvObject = static_cast<IMsTscAx *>(this);
+ else if(riid == IID_IMsRdpClient)
+ pvObject = static_cast<IMsRdpClient *>(this);
+ else if(riid == IID_IMsRdpClient2)
+ pvObject = static_cast<IMsRdpClient2 *>(this);
+ else if(riid == IID_IMsRdpClient3)
+ pvObject = static_cast<IMsRdpClient3 *>(this);
+ else if(riid == IID_IMsRdpClient4)
+ pvObject = static_cast<IMsRdpClient4 *>(this);
+ else if(riid == IID_IMsTscNonScriptable)
+ pvObject = static_cast<IMsTscNonScriptable *>(this);
+ else if(riid == IID_IMsRdpClientNonScriptable)
+ pvObject = static_cast<IMsRdpClientNonScriptable *>(this);
+ else if(riid == IID_IMsRdpClientNonScriptable2)
+ pvObject = static_cast<IMsRdpClientNonScriptable2 *>(this);
+
+ *ppvObject = pvObject;
+
+ if(pvObject)
+ {
+ pvObject->AddRef();
+ return S_OK;
+ }
+
+ return E_NOINTERFACE;
+ }
+
+ ULONG addRef()
+ {
+ return InterlockedIncrement(&m_refCount);
+ }
+
+ ULONG release()
+ {
+ LONG n = InterlockedDecrement(&m_refCount);
+
+ if(n == 0)
+ delete this;
+
+ return n;
+ }
+
+ /* Constructor */
+ RdpClient(REFCLSID classId, unsigned libIndex, IUnknown * punkOuter):
+ // COM/OLE internals
+ m_refCount(0),
+ m_punkOuter(punkOuter),
+ m_classId(classId),
+ m_typeLibIndex(libIndex),
+ m_typeLib(),
+ m_dispTypeInfo(),
+ m_controlWindow(NULL),
+ m_clientSite(),
+ m_inPlaceSite(),
+ m_adviseHolder(),
+ m_freezeEvents(0),
+ m_uiActive(false),
+ m_SafetyOptions(),
+
+#ifdef _DEBUG
+ m_apartmentThreadId(GetCurrentThreadId()),
+#endif
+
+ // rdesktop-core interface
+ m_protocolState(),
+ m_protocolThread(),
+
+ // Properties
+ m_Server(),
+ m_Domain(),
+ m_UserName(),
+ m_DisconnectedText(),
+ m_ConnectingText(),
+ m_FullScreenTitle(),
+ m_StartProgram(),
+ m_WorkDir(),
+ m_LoadBalanceInfo(),
+ m_ConnectedStatusText(),
+ m_ClearTextPassword(),
+ m_RdpdrLocalPrintingDocName(),
+ m_RdpdrClipCleanTempDirString(),
+ m_RdpdrClipPasteInfoString(),
+ m_UIParentWindowHandle(),
+ m_DesktopWidth(),
+ m_DesktopHeight(),
+ m_StartConnected(),
+ m_ColorDepth(16),
+ m_KeyboardHookMode(2),
+ m_AudioRedirectionMode(0),
+ m_TransportType(1), // BUGBUG: ??? what's this ???
+ m_SasSequence(0xAA03), // BUGBUG: ??? what's this ???
+ m_RDPPort(3389),
+ m_HotKeyFullScreen(VK_CANCEL),
+ m_HotKeyAltEsc(VK_INSERT),
+ m_HotKeyAltShiftTab(VK_NEXT),
+ m_HotKeyAltSpace(VK_DELETE),
+ m_HotKeyAltTab(VK_PRIOR),
+ m_HotKeyCtrlAltDel(VK_END),
+ m_HotKeyCtrlEsc(VK_HOME),
+ m_orderDrawThresold(0),
+ m_BitmapCacheSize(1500),
+ m_BitmapVirtualCacheSize(10),
+ m_brushSupportLevel(),
+ m_minInputSendInterval(),
+ m_InputEventsAtOnce(),
+ m_maxEventCount(),
+ m_keepAliveInternal(0),
+ m_shutdownTimeout(10),
+ m_overallConnectionTimeout(120),
+ m_singleConnectionTimeout(30),
+ m_MinutesToIdleTimeout(0),
+ m_BitmapVirtualCache16BppSize(20),
+ m_BitmapVirtualCache24BppSize(30),
+ m_PerformanceFlags(),
+ m_MaxReconnectAttempts(20),
+ m_AuthenticationLevel(0),
+ m_ExtendedDisconnectReason(MSTSCLib::exDiscReasonNoInfo),
+ m_Connected(false),
+ m_Compress(true),
+ m_BitmapPersistence(true),
+ m_allowBackgroundInput(false),
+ m_ContainerHandledFullScreen(false),
+ m_DisableRdpdr(false),
+ m_SecuredSettingsEnabled(true),
+ m_FullScreen(false),
+ m_AcceleratorPassthrough(true),
+ m_ShadowBitmap(true),
+ m_EncryptionEnabled(true),
+ m_DedicatedTerminal(false),
+ m_DisableCtrlAltDel(true),
+ m_EnableWindowsKey(true),
+ m_DoubleClickDetect(false),
+ m_MaximizeShell(true),
+ m_ScaleBitmapCachesByBpp(false),
+ m_CachePersistenceActive(false),
+ m_ConnectToServerConsole(false),
+ m_SmartSizing(false),
+ m_DisplayConnectionBar(true),
+ m_PinConnectionBar(true),
+ m_GrabFocusOnConnect(true),
+ m_RedirectDrives(false),
+ m_RedirectPrinters(false),
+ m_RedirectPorts(false),
+ m_RedirectSmartCards(false),
+ m_NotifyTSPublicKey(false),
+ m_CanAutoReconnect(false),
+ m_EnableAutoReconnect(true),
+ m_ConnectionBarShowMinimizeButton(true),
+ m_ConnectionBarShowRestoreButton(true)
+ {
+ if(m_punkOuter == NULL)
+ m_punkOuter = &m_inner;
+ }
+
+ /* Destructor */
+ ~RdpClient()
+ {
+ assert(m_refCount == 0);
+
+ if(m_Connected)
+ {
+ // Terminate the protocol thread
+ TerminateProtocolThread();
+
+ // Dispatch the RDPC_WM_DISCONNECT message sent by the dying thread
+ MSG msg;
+ PeekMessage(&msg, m_controlWindow, 0, 0, PM_NOREMOVE);
+
+ assert(!m_Connected);
+ }
+
+ DestroyControlWindow();
+
+ if(m_typeLib)
+ m_typeLib->Release();
+
+ if(m_dispTypeInfo)
+ m_dispTypeInfo->Release();
+
+ MSTSCLib::IMsTscAxEvents ** sinks = GetSinks();
+
+ for(size_t i = 0; i < m_EventSinksCount; ++ i)
+ sinks[i]->Release();
+
+ if(m_EventSinksCount > 1)
+ delete[] m_EventSinks;
+
+ if(m_clientSite)
+ m_clientSite->Release();
+
+ if(m_inPlaceSite)
+ m_inPlaceSite->Release();
+
+ if(m_adviseHolder)
+ m_adviseHolder->Release();
+
+ SysFreeString(m_Domain);
+ SysFreeString(m_UserName);
+ SysFreeString(m_DisconnectedText);
+ SysFreeString(m_DisconnectedText);
+ SysFreeString(m_FullScreenTitle);
+ SysFreeString(m_StartProgram);
+ SysFreeString(m_WorkDir);
+ SysFreeString(m_ConnectedStatusText);
+ SysFreeString(m_ClearTextPassword);
+ SysFreeString(m_RdpdrLocalPrintingDocName);
+ SysFreeString(m_RdpdrClipCleanTempDirString);
+ SysFreeString(m_RdpdrClipPasteInfoString);
+
+ FreeLpsz(m_LoadBalanceInfo);
+ FreeLpsz(m_Server);
+
+ unlockServer();
+ }
+
+ /* Advanced settings wrapper */
+ friend class AdvancedSettings;
+
+ class AdvancedSettings SEALED_: public MSTSCLib::IMsRdpClientAdvancedSettings4
+ {
+ private:
+ RdpClient * Outer()
+ {
+ return InnerToOuter(this);
+ }
+
+ const RdpClient * Outer() const
+ {
+ return InnerToOuter(this);
+ }
+
+ /* IDispatch type information */
+ ITypeInfo * m_dispTypeInfo;
+
+ HRESULT LoadDispTypeInfo()
+ {
+ if(m_dispTypeInfo)
+ return S_OK;
+
+ HRESULT hr = Outer()->LoadTypeLibrary();
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(MSTSCLib::IID_IMsRdpClientAdvancedSettings4 == MSTSCLib_Redist::IID_IMsRdpClientAdvancedSettings4);
+
+ hr = Outer()->m_typeLib->GetTypeInfoOfGuid(MSTSCLib::IID_IMsRdpClientAdvancedSettings4, &m_dispTypeInfo);
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(m_dispTypeInfo);
+ return S_OK;
+ }
+
+ HRESULT AcquireDispTypeInfo(ITypeInfo ** ppTI)
+ {
+ HRESULT hr = LoadDispTypeInfo();
+
+ if(FAILED(hr))
+ return hr;
+
+ m_dispTypeInfo->AddRef();
+ *ppTI = m_dispTypeInfo;
+ return S_OK;
+ }
+
+ public:
+ ~AdvancedSettings()
+ {
+ if(m_dispTypeInfo)
+ m_dispTypeInfo->Release();
+ }
+
+ /* IUnknown */
+ virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ using namespace MSTSCLib;
+
+ if
+ (
+ riid == IID_IUnknown ||
+ riid == IID_IDispatch ||
+ riid == IID_IMsTscAdvancedSettings ||
+ riid == IID_IMsRdpClientAdvancedSettings ||
+ riid == IID_IMsRdpClientAdvancedSettings2 ||
+ riid == IID_IMsRdpClientAdvancedSettings3 ||
+ riid == IID_IMsRdpClientAdvancedSettings4
+ )
+ {
+ *ppvObject = this;
+ Outer()->addRef();
+ return S_OK;
+ }
+ else
+ {
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::AddRef()
+ {
+ return Outer()->addRef();
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::Release()
+ {
+ return Outer()->release();
+ }
+
+ /* IDispatch */
+ virtual STDMETHODIMP IDispatch::GetTypeInfoCount(UINT * pctinfo)
+ {
+ *pctinfo = 1;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IDispatch::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
+ {
+ if(iTInfo != 0)
+ return DISP_E_BADINDEX;
+
+ return AcquireDispTypeInfo(ppTInfo);
+ }
+
+ virtual STDMETHODIMP IDispatch::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
+ {
+ HRESULT hr = LoadDispTypeInfo();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_dispTypeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId);
+ }
+
+ virtual STDMETHODIMP IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr)
+ {
+ return m_dispTypeInfo->Invoke
+ (
+ static_cast<MSTSCLib::IMsRdpClientAdvancedSettings4 *>(this),
+ dispIdMember,
+ wFlags,
+ pDispParams,
+ pVarResult,
+ pExcepInfo,
+ puArgErr
+ );
+ }
+
+ /* IMsTscAdvancedSettings */
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_Compress(long pcompress)
+ {
+ return Outer()->SetProperty(Outer()->m_Compress, pcompress);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_Compress(long * pcompress) const
+ {
+ return Outer()->GetProperty(Outer()->m_Compress, pcompress);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_BitmapPeristence(long pbitmapPeristence)
+ {
+ return Outer()->SetProperty(Outer()->m_BitmapPersistence, pbitmapPeristence);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_BitmapPeristence(long * pbitmapPeristence) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapPersistence, pbitmapPeristence);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_allowBackgroundInput(long pallowBackgroundInput)
+ {
+ if(Outer()->IsSafeForScripting())
+ return S_FALSE;
+
+ return Outer()->SetProperty(Outer()->m_allowBackgroundInput, pallowBackgroundInput);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_allowBackgroundInput(long * pallowBackgroundInput) const
+ {
+ return Outer()->GetProperty(Outer()->m_allowBackgroundInput, pallowBackgroundInput);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_KeyBoardLayoutStr(BSTR rhs)
+ {
+ return Outer()->SetProperty(Outer()->m_KeyboardLayoutString, rhs);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_PluginDlls(BSTR rhs)
+ {
+ // TODO: split rhs into an array
+
+ // Control marked safe for scripting: only allow filenames
+ if(Outer()->IsSafeForScripting())
+ {
+ // TODO: validate entries
+ // TODO: replace each entry with a full path based on the Virtual Channel DLL path
+ }
+
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconFile(BSTR rhs)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_IconIndex(long rhs)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_ContainerHandledFullScreen(long pContainerHandledFullScreen)
+ {
+ if(Outer()->IsSafeForScripting())
+ return S_FALSE;
+
+ return Outer()->SetProperty(Outer()->m_ContainerHandledFullScreen, pContainerHandledFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_ContainerHandledFullScreen(long * pContainerHandledFullScreen) const
+ {
+ return Outer()->GetProperty(Outer()->m_ContainerHandledFullScreen, pContainerHandledFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::put_DisableRdpdr(long pDisableRdpdr)
+ {
+ return Outer()->SetProperty(Outer()->m_DisableRdpdr, pDisableRdpdr);
+ }
+
+ virtual STDMETHODIMP IMsTscAdvancedSettings::get_DisableRdpdr(long * pDisableRdpdr) const
+ {
+ return Outer()->GetProperty(Outer()->m_DisableRdpdr, pDisableRdpdr);
+ }
+
+ /* IMsRdpClientAdvancedSettings */
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmoothScroll(long psmoothScroll)
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmoothScroll(long * psmoothScroll) const
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_AcceleratorPassthrough(long pacceleratorPassthrough)
+ {
+ return Outer()->SetProperty(Outer()->m_AcceleratorPassthrough, pacceleratorPassthrough);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_AcceleratorPassthrough(long * pacceleratorPassthrough) const
+ {
+ return Outer()->GetProperty(Outer()->m_AcceleratorPassthrough, pacceleratorPassthrough);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ShadowBitmap(long pshadowBitmap)
+ {
+ return Outer()->SetProperty(Outer()->m_ShadowBitmap, pshadowBitmap);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ShadowBitmap(long * pshadowBitmap) const
+ {
+ return Outer()->GetProperty(Outer()->m_ShadowBitmap, pshadowBitmap);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_TransportType(long ptransportType)
+ {
+ // Reserved
+ return Outer()->SetProperty(Outer()->m_TransportType, ptransportType);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_TransportType(long * ptransportType) const
+ {
+ // Reserved
+ return Outer()->GetProperty(Outer()->m_TransportType, ptransportType);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SasSequence(long psasSequence)
+ {
+ // Reserved
+ return Outer()->SetProperty(Outer()->m_SasSequence, psasSequence);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SasSequence(long * psasSequence) const
+ {
+ // Reserved
+ return Outer()->GetProperty(Outer()->m_SasSequence, psasSequence);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EncryptionEnabled(long pencryptionEnabled)
+ {
+ return Outer()->SetProperty(Outer()->m_EncryptionEnabled, pencryptionEnabled);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EncryptionEnabled(long * pencryptionEnabled) const
+ {
+ return Outer()->GetProperty(Outer()->m_EncryptionEnabled, pencryptionEnabled);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DedicatedTerminal(long pdedicatedTerminal)
+ {
+ return Outer()->SetProperty(Outer()->m_DedicatedTerminal, pdedicatedTerminal);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DedicatedTerminal(long * pdedicatedTerminal) const
+ {
+ return Outer()->GetProperty(Outer()->m_DedicatedTerminal, pdedicatedTerminal);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RDPPort(long prdpPort)
+ {
+ if(prdpPort == 0 || prdpPort > 65535)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_RDPPort, prdpPort);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RDPPort(long * prdpPort) const
+ {
+ return Outer()->GetProperty(Outer()->m_RDPPort, prdpPort);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableMouse(long penableMouse)
+ {
+ return S_FALSE; // TBD? implement?
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableMouse(long * penableMouse) const
+ {
+ return S_FALSE; // TBD? implement?
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisableCtrlAltDel(long pdisableCtrlAltDel)
+ {
+ return Outer()->SetProperty(Outer()->m_DisableCtrlAltDel, pdisableCtrlAltDel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisableCtrlAltDel(long * pdisableCtrlAltDel) const
+ {
+ return Outer()->GetProperty(Outer()->m_DisableCtrlAltDel, pdisableCtrlAltDel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_EnableWindowsKey(long penableWindowsKey)
+ {
+ return Outer()->SetProperty(Outer()->m_EnableWindowsKey, penableWindowsKey);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_EnableWindowsKey(long * penableWindowsKey) const
+ {
+ return Outer()->GetProperty(Outer()->m_EnableWindowsKey, penableWindowsKey);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DoubleClickDetect(long pdoubleClickDetect)
+ {
+ return Outer()->SetProperty(Outer()->m_DoubleClickDetect, pdoubleClickDetect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DoubleClickDetect(long * pdoubleClickDetect) const
+ {
+ return Outer()->GetProperty(Outer()->m_DoubleClickDetect, pdoubleClickDetect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MaximizeShell(long pmaximizeShell)
+ {
+ return Outer()->SetProperty(Outer()->m_MaximizeShell, pmaximizeShell);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MaximizeShell(long * pmaximizeShell) const
+ {
+ return Outer()->GetProperty(Outer()->m_MaximizeShell, pmaximizeShell);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyFullScreen(long photKeyFullScreen)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyFullScreen, photKeyFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyFullScreen(long * photKeyFullScreen) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyFullScreen, photKeyFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlEsc(long photKeyCtrlEsc)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyCtrlEsc, photKeyCtrlEsc);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlEsc(long * photKeyCtrlEsc) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyCtrlEsc, photKeyCtrlEsc);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltEsc(long photKeyAltEsc)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyAltEsc, photKeyAltEsc);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltEsc(long * photKeyAltEsc) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyAltEsc, photKeyAltEsc);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltTab(long photKeyAltTab)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyAltTab, photKeyAltTab);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltTab(long * photKeyAltTab) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyAltTab, photKeyAltTab);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltShiftTab(long photKeyAltShiftTab)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyAltShiftTab, photKeyAltShiftTab);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltShiftTab(long * photKeyAltShiftTab) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyAltShiftTab, photKeyAltShiftTab);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyAltSpace(long photKeyAltSpace)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyAltSpace, photKeyAltSpace);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyAltSpace(long * photKeyAltSpace) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyAltSpace, photKeyAltSpace);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_HotKeyCtrlAltDel(long photKeyCtrlAltDel)
+ {
+ return Outer()->SetProperty(Outer()->m_HotKeyCtrlAltDel, photKeyCtrlAltDel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_HotKeyCtrlAltDel(long * photKeyCtrlAltDel) const
+ {
+ return Outer()->GetProperty(Outer()->m_HotKeyCtrlAltDel, photKeyCtrlAltDel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_orderDrawThreshold(long porderDrawThreshold)
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_orderDrawThreshold(long * porderDrawThreshold) const
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapCacheSize(long pbitmapCacheSize)
+ {
+ // NOTE: the upper bound of "32" for a field with a default value of 1500 seems to be a bug
+ if(pbitmapCacheSize < 0 || pbitmapCacheSize > 32)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_BitmapCacheSize, pbitmapCacheSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapCacheSize(long * pbitmapCacheSize) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapCacheSize, pbitmapCacheSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCacheSize(long pbitmapVirtualCacheSize)
+ {
+ if(pbitmapVirtualCacheSize < 0 || pbitmapVirtualCacheSize > 32)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_BitmapVirtualCacheSize, pbitmapVirtualCacheSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCacheSize(long * pbitmapVirtualCacheSize) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapVirtualCacheSize, pbitmapVirtualCacheSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ScaleBitmapCachesByBPP(long pbScale)
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ScaleBitmapCachesByBPP(long * pbScale) const
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NumBitmapCaches(long pnumBitmapCaches)
+ {
+ return Outer()->SetProperty(Outer()->m_NumBitmapCaches, pnumBitmapCaches);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NumBitmapCaches(long * pnumBitmapCaches) const
+ {
+ return Outer()->GetProperty(Outer()->m_NumBitmapCaches, pnumBitmapCaches);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_CachePersistenceActive(long pcachePersistenceActive)
+ {
+ return Outer()->SetProperty(Outer()->m_CachePersistenceActive, pcachePersistenceActive);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_CachePersistenceActive(long * pcachePersistenceActive) const
+ {
+ return Outer()->GetProperty(Outer()->m_CachePersistenceActive, pcachePersistenceActive);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PersistCacheDirectory(BSTR rhs)
+ {
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_brushSupportLevel(long pbrushSupportLevel)
+ {
+ return Outer()->SetProperty(Outer()->m_brushSupportLevel, pbrushSupportLevel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_brushSupportLevel(long * pbrushSupportLevel) const
+ {
+ return Outer()->GetProperty(Outer()->m_brushSupportLevel, pbrushSupportLevel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_minInputSendInterval(long pminInputSendInterval)
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_minInputSendInterval(long * pminInputSendInterval) const
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_InputEventsAtOnce(long pinputEventsAtOnce)
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_InputEventsAtOnce(long * pinputEventsAtOnce) const
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_maxEventCount(long pmaxEventCount)
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_maxEventCount(long * pmaxEventCount) const
+ {
+ // TODO
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_keepAliveInterval(long pkeepAliveInterval)
+ {
+ if(pkeepAliveInterval && pkeepAliveInterval < 10)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_keepAliveInternal, pkeepAliveInterval);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_keepAliveInterval(long * pkeepAliveInterval) const
+ {
+ return Outer()->GetProperty(Outer()->m_keepAliveInternal, pkeepAliveInterval);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_shutdownTimeout(long pshutdownTimeout)
+ {
+ if(pshutdownTimeout >= 600)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_shutdownTimeout, pshutdownTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_shutdownTimeout(long * pshutdownTimeout) const
+ {
+ return Outer()->GetProperty(Outer()->m_shutdownTimeout, pshutdownTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_overallConnectionTimeout(long poverallConnectionTimeout)
+ {
+ if(poverallConnectionTimeout < 0 || poverallConnectionTimeout >= 600)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_overallConnectionTimeout, poverallConnectionTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_overallConnectionTimeout(long * poverallConnectionTimeout) const
+ {
+ return Outer()->GetProperty(Outer()->m_overallConnectionTimeout, poverallConnectionTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_singleConnectionTimeout(long psingleConnectionTimeout)
+ {
+ if(psingleConnectionTimeout >= 600)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_singleConnectionTimeout, psingleConnectionTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_singleConnectionTimeout(long * psingleConnectionTimeout) const
+ {
+ return Outer()->GetProperty(Outer()->m_singleConnectionTimeout, psingleConnectionTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardType(long pkeyboardType)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardType(long * pkeyboardType) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardSubType(long pkeyboardSubType)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardSubType(long * pkeyboardSubType) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_KeyboardFunctionKey(long pkeyboardFunctionKey)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_KeyboardFunctionKey(long * pkeyboardFunctionKey) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_WinceFixedPalette(long pwinceFixedPalette)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_WinceFixedPalette(long * pwinceFixedPalette) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectToServerConsole(VARIANT_BOOL pConnectToConsole)
+ {
+ return Outer()->SetProperty(Outer()->m_ConnectToServerConsole, pConnectToConsole);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_ConnectToServerConsole(VARIANT_BOOL * pConnectToConsole) const
+ {
+ return Outer()->GetProperty(Outer()->m_ConnectToServerConsole, pConnectToConsole);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapPersistence(long pbitmapPersistence)
+ {
+ return put_BitmapPeristence(pbitmapPersistence);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapPersistence(long * pbitmapPersistence) const
+ {
+ return get_BitmapPeristence(pbitmapPersistence);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_MinutesToIdleTimeout(long pminutesToIdleTimeout)
+ {
+ if(pminutesToIdleTimeout > 240)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_MinutesToIdleTimeout, pminutesToIdleTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_MinutesToIdleTimeout(long * pminutesToIdleTimeout) const
+ {
+ return Outer()->GetProperty(Outer()->m_MinutesToIdleTimeout, pminutesToIdleTimeout);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_SmartSizing(VARIANT_BOOL pfSmartSizing)
+ {
+ return Outer()->SetProperty(Outer()->m_SmartSizing, pfSmartSizing);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_SmartSizing(VARIANT_BOOL * pfSmartSizing) const
+ {
+ return Outer()->GetProperty(Outer()->m_SmartSizing, pfSmartSizing);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrLocalPrintingDocName(BSTR pLocalPrintingDocName)
+ {
+ return Outer()->SetProperty(Outer()->m_RdpdrLocalPrintingDocName, pLocalPrintingDocName);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrLocalPrintingDocName(BSTR * pLocalPrintingDocName) const
+ {
+ return Outer()->GetProperty(Outer()->m_RdpdrLocalPrintingDocName, pLocalPrintingDocName);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipCleanTempDirString(BSTR clipCleanTempDirString)
+ {
+ return Outer()->SetProperty(Outer()->m_RdpdrClipCleanTempDirString, clipCleanTempDirString);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipCleanTempDirString(BSTR * clipCleanTempDirString) const
+ {
+ return Outer()->GetProperty(Outer()->m_RdpdrClipCleanTempDirString, clipCleanTempDirString);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RdpdrClipPasteInfoString(BSTR clipPasteInfoString)
+ {
+ return Outer()->SetProperty(Outer()->m_RdpdrClipPasteInfoString, clipPasteInfoString);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RdpdrClipPasteInfoString(BSTR * clipPasteInfoString) const
+ {
+ return Outer()->GetProperty(Outer()->m_RdpdrClipPasteInfoString, clipPasteInfoString);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ClearTextPassword(BSTR rhs)
+ {
+ return Outer()->put_ClearTextPassword(rhs);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_DisplayConnectionBar(VARIANT_BOOL pDisplayConnectionBar)
+ {
+ if(!pDisplayConnectionBar && Outer()->IsSafeForScripting())
+ return E_FAIL;
+
+ return Outer()->SetProperty(Outer()->m_DisplayConnectionBar, pDisplayConnectionBar);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_DisplayConnectionBar(VARIANT_BOOL * pDisplayConnectionBar) const
+ {
+ return Outer()->GetProperty(Outer()->m_DisplayConnectionBar, pDisplayConnectionBar);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PinConnectionBar(VARIANT_BOOL pPinConnectionBar)
+ {
+ if(Outer()->IsSafeForScripting())
+ return E_NOTIMPL;
+
+ return Outer()->SetProperty(Outer()->m_PinConnectionBar, pPinConnectionBar);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PinConnectionBar(VARIANT_BOOL * pPinConnectionBar) const
+ {
+ return Outer()->GetProperty(Outer()->m_PinConnectionBar, pPinConnectionBar);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_GrabFocusOnConnect(VARIANT_BOOL pfGrabFocusOnConnect)
+ {
+ return Outer()->SetProperty(Outer()->m_GrabFocusOnConnect, pfGrabFocusOnConnect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_GrabFocusOnConnect(VARIANT_BOOL * pfGrabFocusOnConnect) const
+ {
+ return Outer()->GetProperty(Outer()->m_GrabFocusOnConnect, pfGrabFocusOnConnect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_LoadBalanceInfo(BSTR pLBInfo)
+ {
+ return Outer()->SetProperty(Outer()->m_LoadBalanceInfo, pLBInfo);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_LoadBalanceInfo(BSTR * pLBInfo) const
+ {
+ return Outer()->GetProperty(Outer()->m_LoadBalanceInfo, pLBInfo);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectDrives(VARIANT_BOOL pRedirectDrives)
+ {
+ return Outer()->SetProperty(Outer()->m_RedirectDrives, pRedirectDrives);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectDrives(VARIANT_BOOL * pRedirectDrives) const
+ {
+ return Outer()->GetProperty(Outer()->m_RedirectDrives, pRedirectDrives);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPrinters(VARIANT_BOOL pRedirectPrinters)
+ {
+ return Outer()->SetProperty(Outer()->m_RedirectPrinters, pRedirectPrinters);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPrinters(VARIANT_BOOL * pRedirectPrinters) const
+ {
+ return Outer()->GetProperty(Outer()->m_RedirectPrinters, pRedirectPrinters);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectPorts(VARIANT_BOOL pRedirectPorts)
+ {
+ return Outer()->SetProperty(Outer()->m_RedirectPorts, pRedirectPorts);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectPorts(VARIANT_BOOL * pRedirectPorts) const
+ {
+ return Outer()->GetProperty(Outer()->m_RedirectPorts, pRedirectPorts);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_RedirectSmartCards(VARIANT_BOOL pRedirectSmartCards)
+ {
+ return Outer()->SetProperty(Outer()->m_RedirectSmartCards, pRedirectSmartCards);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_RedirectSmartCards(VARIANT_BOOL * pRedirectSmartCards) const
+ {
+ return Outer()->GetProperty(Outer()->m_RedirectSmartCards, pRedirectSmartCards);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache16BppSize(long pBitmapVirtualCache16BppSize)
+ {
+ if(pBitmapVirtualCache16BppSize < 0 || pBitmapVirtualCache16BppSize > 32)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_BitmapVirtualCache16BppSize, pBitmapVirtualCache16BppSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache16BppSize(long * pBitmapVirtualCache16BppSize) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapVirtualCache16BppSize, pBitmapVirtualCache16BppSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_BitmapVirtualCache24BppSize(long pBitmapVirtualCache24BppSize)
+ {
+ if(pBitmapVirtualCache24BppSize < 0 || pBitmapVirtualCache24BppSize > 32)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_BitmapVirtualCache24BppSize, pBitmapVirtualCache24BppSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_BitmapVirtualCache24BppSize(long * pBitmapVirtualCache24BppSize) const
+ {
+ return Outer()->GetProperty(Outer()->m_BitmapVirtualCache24BppSize, pBitmapVirtualCache24BppSize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_PerformanceFlags(long pDisableList)
+ {
+ return Outer()->SetProperty(Outer()->m_PerformanceFlags, pDisableList);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_PerformanceFlags(long * pDisableList) const
+ {
+ return Outer()->GetProperty(Outer()->m_PerformanceFlags, pDisableList);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_ConnectWithEndpoint(VARIANT * rhs)
+ {
+ // TBD? the Microsoft client implements this, but what does it mean?
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::put_NotifyTSPublicKey(VARIANT_BOOL pfNotify)
+ {
+ return Outer()->SetProperty(Outer()->m_NotifyTSPublicKey, pfNotify);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings::get_NotifyTSPublicKey(VARIANT_BOOL * pfNotify) const
+ {
+ return Outer()->GetProperty(Outer()->m_NotifyTSPublicKey, pfNotify);
+ }
+
+ /* IMsRdpClientAdvancedSettings2 */
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_CanAutoReconnect(VARIANT_BOOL * pfCanAutoReconnect) const
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_EnableAutoReconnect(VARIANT_BOOL pfEnableAutoReconnect)
+ {
+ return Outer()->SetProperty(Outer()->m_EnableAutoReconnect, pfEnableAutoReconnect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_EnableAutoReconnect(VARIANT_BOOL * pfEnableAutoReconnect) const
+ {
+ return Outer()->GetProperty(Outer()->m_EnableAutoReconnect, pfEnableAutoReconnect);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::put_MaxReconnectAttempts(long pMaxReconnectAttempts)
+ {
+ if(pMaxReconnectAttempts < 0 || pMaxReconnectAttempts > 200)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_MaxReconnectAttempts, pMaxReconnectAttempts);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings2::get_MaxReconnectAttempts(long * pMaxReconnectAttempts) const
+ {
+ return Outer()->GetProperty(Outer()->m_MaxReconnectAttempts, pMaxReconnectAttempts);
+ }
+
+ /* IMsRdpClientAdvancedSettings3 */
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowMinimizeButton(VARIANT_BOOL pfShowMinimize)
+ {
+ return Outer()->SetProperty(Outer()->m_ConnectionBarShowMinimizeButton, pfShowMinimize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowMinimizeButton(VARIANT_BOOL * pfShowMinimize) const
+ {
+ return Outer()->GetProperty(Outer()->m_ConnectionBarShowMinimizeButton, pfShowMinimize);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::put_ConnectionBarShowRestoreButton(VARIANT_BOOL pfShowRestore)
+ {
+ return Outer()->SetProperty(Outer()->m_ConnectionBarShowRestoreButton, pfShowRestore);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings3::get_ConnectionBarShowRestoreButton(VARIANT_BOOL * pfShowRestore) const
+ {
+ return Outer()->GetProperty(Outer()->m_ConnectionBarShowRestoreButton, pfShowRestore);
+ }
+
+ /* IMsRdpClientAdvancedSettings4 */
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::put_AuthenticationLevel(unsigned int puiAuthLevel)
+ {
+ // TODO: this isn't implemented in rdesktop yet...
+ return Outer()->SetProperty(Outer()->m_AuthenticationLevel, puiAuthLevel);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientAdvancedSettings4::get_AuthenticationLevel(unsigned int * puiAuthLevel) const
+ {
+ return Outer()->GetProperty(Outer()->m_AuthenticationLevel, puiAuthLevel);
+ }
+ }
+ m_advancedSettings;
+
+ template<class Interface> HRESULT GetAdvancedSettings(Interface ** ppAdvSettings)
+ {
+ addRef();
+ *ppAdvSettings = &m_advancedSettings;
+ return S_OK;
+ }
+
+ /* Secured settings wrapper */
+ friend class SecuredSettings;
+
+ class SecuredSettings SEALED_: public MSTSCLib::IMsRdpClientSecuredSettings
+ {
+ private:
+ RdpClient * Outer()
+ {
+ return InnerToOuter(this);
+ }
+
+ const RdpClient * Outer() const
+ {
+ return InnerToOuter(this);
+ }
+
+ /* IDispatch type information */
+ ITypeInfo * m_dispTypeInfo;
+
+ HRESULT LoadDispTypeInfo()
+ {
+ if(m_dispTypeInfo)
+ return S_OK;
+
+ HRESULT hr = Outer()->LoadTypeLibrary();
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(MSTSCLib::IID_IMsRdpClientSecuredSettings == MSTSCLib_Redist::IID_IMsRdpClientSecuredSettings);
+
+ hr = Outer()->m_typeLib->GetTypeInfoOfGuid(MSTSCLib::IID_IMsRdpClientSecuredSettings, &m_dispTypeInfo);
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(m_dispTypeInfo);
+ return S_OK;
+ }
+
+ HRESULT AcquireDispTypeInfo(ITypeInfo ** ppTI)
+ {
+ HRESULT hr = LoadDispTypeInfo();
+
+ if(FAILED(hr))
+ return hr;
+
+ m_dispTypeInfo->AddRef();
+ *ppTI = m_dispTypeInfo;
+ return S_OK;
+ }
+
+ public:
+ ~SecuredSettings()
+ {
+ if(m_dispTypeInfo)
+ m_dispTypeInfo->Release();
+ }
+
+ /* IUnknown */
+ virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ using namespace MSTSCLib;
+
+ if
+ (
+ riid == IID_IUnknown ||
+ riid == IID_IDispatch ||
+ riid == IID_IMsTscSecuredSettings ||
+ riid == IID_IMsRdpClientSecuredSettings
+ )
+ {
+ *ppvObject = this;
+ Outer()->addRef();
+ return S_OK;
+ }
+ else
+ {
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::AddRef()
+ {
+ return Outer()->addRef();
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::Release()
+ {
+ return Outer()->release();
+ }
+
+ /* IDispatch */
+ virtual STDMETHODIMP IDispatch::GetTypeInfoCount(UINT * pctinfo)
+ {
+ *pctinfo = 1;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IDispatch::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
+ {
+ if(iTInfo != 0)
+ return DISP_E_BADINDEX;
+
+ return AcquireDispTypeInfo(ppTInfo);
+ }
+
+ virtual STDMETHODIMP IDispatch::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
+ {
+ HRESULT hr = LoadDispTypeInfo();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_dispTypeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId);
+ }
+
+ virtual STDMETHODIMP IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr)
+ {
+ return m_dispTypeInfo->Invoke
+ (
+ static_cast<MSTSCLib::IMsRdpClientSecuredSettings *>(this),
+ dispIdMember,
+ wFlags,
+ pDispParams,
+ pVarResult,
+ pExcepInfo,
+ puArgErr
+ );
+ }
+
+ /* IMsTscSecuredSettings */
+ virtual STDMETHODIMP IMsTscSecuredSettings::put_StartProgram(BSTR pStartProgram)
+ {
+ return Outer()->SetProperty(Outer()->m_StartProgram, pStartProgram);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::get_StartProgram(BSTR * pStartProgram) const
+ {
+ return Outer()->GetProperty(Outer()->m_StartProgram, pStartProgram);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::put_WorkDir(BSTR pWorkDir)
+ {
+ return Outer()->SetProperty(Outer()->m_WorkDir, pWorkDir);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::get_WorkDir(BSTR * pWorkDir) const
+ {
+ return Outer()->GetProperty(Outer()->m_WorkDir, pWorkDir);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::put_FullScreen(long pfFullScreen)
+ {
+ return Outer()->put_FullScreen(!!pfFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsTscSecuredSettings::get_FullScreen(long * pfFullScreen) const
+ {
+ return Outer()->GetProperty(Outer()->m_FullScreen, pfFullScreen);
+ }
+
+ /* IMsRdpClientSecuredSettings */
+ virtual STDMETHODIMP IMsRdpClientSecuredSettings::put_KeyboardHookMode(long pkeyboardHookMode)
+ {
+ if(pkeyboardHookMode < 0 || pkeyboardHookMode > 2)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_KeyboardHookMode, pkeyboardHookMode);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientSecuredSettings::get_KeyboardHookMode(long * pkeyboardHookMode) const
+ {
+ return Outer()->GetProperty(Outer()->m_KeyboardHookMode, pkeyboardHookMode);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientSecuredSettings::put_AudioRedirectionMode(long pAudioRedirectionMode)
+ {
+ if(pAudioRedirectionMode < 0 || pAudioRedirectionMode > 2)
+ return E_INVALIDARG;
+
+ return Outer()->SetProperty(Outer()->m_AudioRedirectionMode, pAudioRedirectionMode);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientSecuredSettings::get_AudioRedirectionMode(long * pAudioRedirectionMode) const
+ {
+ return Outer()->GetProperty(Outer()->m_AudioRedirectionMode, pAudioRedirectionMode);
+ }
+ }
+ m_securedSettings;
+
+ template<class Interface> HRESULT GetSecuredSettings(Interface ** ppSecuredSettings)
+ {
+ if(!m_SecuredSettingsEnabled)
+ return E_FAIL;
+
+ addRef();
+ *ppSecuredSettings = &m_securedSettings;
+ return S_OK;
+ }
+
+ /* Type library loading */
+ HRESULT LoadTypeLibrary()
+ {
+ if(m_typeLib)
+ return S_OK;
+
+ // Get the DLL name of the ActiveX control
+ WCHAR szPath[MAX_PATH + 1];
+ DWORD cchPathLen = GetModuleFileNameW(GetCurrentModule(), szPath, ARRAYSIZE(szPath) - 1);
+
+ if(cchPathLen == 0)
+ return HRESULT_FROM_WIN32(GetLastError());
+
+ if(cchPathLen > ((ARRAYSIZE(szPath) - 1) - 2))
+ return E_FAIL;
+
+ // Append the resource id of the type library
+ assert(m_typeLibIndex < 10);
+
+ szPath[cchPathLen + 0] = L'\\';
+ szPath[cchPathLen + 1] = static_cast<WCHAR>(L'0' + m_typeLibIndex);
+ szPath[cchPathLen + 2] = 0;
+
+ // Load the type library
+ HRESULT hr = LoadTypeLibEx(szPath, REGKIND_NONE, &m_typeLib);
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(m_typeLib);
+ return S_OK;
+ }
+
+ /* IDispatch type information */
+ HRESULT LoadDispTypeInfo()
+ {
+ if(m_dispTypeInfo)
+ return S_OK;
+
+ HRESULT hr = LoadTypeLibrary();
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(MSTSCLib::IID_IMsRdpClient4 == MSTSCLib_Redist::IID_IMsRdpClient4);
+
+ hr = m_typeLib->GetTypeInfoOfGuid(MSTSCLib::IID_IMsRdpClient4, &m_dispTypeInfo);
+
+ if(FAILED(hr))
+ return hr;
+
+ assert(m_dispTypeInfo);
+ return S_OK;
+ }
+
+ HRESULT AcquireDispTypeInfo(ITypeInfo ** ppTI)
+ {
+ HRESULT hr = LoadDispTypeInfo();
+
+ if(FAILED(hr))
+ return hr;
+
+ m_dispTypeInfo->AddRef();
+ *ppTI = m_dispTypeInfo;
+ return S_OK;
+ }
+
+public:
+ /* Helpers for our various embedded children */
+ static RdpClient * InnerToOuter(RdpClientInner * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_inner);
+ }
+
+ static RdpClient * InnerToOuter(AdvancedSettings * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_advancedSettings);
+ }
+
+ static RdpClient * InnerToOuter(SecuredSettings * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_securedSettings);
+ }
+
+ static RdpClient * InnerToOuter(RDPCLIENT * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_protocolState);
+ }
+
+ static const RdpClient * InnerToOuter(const RdpClientInner * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_inner);
+ }
+
+ static const RdpClient * InnerToOuter(const AdvancedSettings * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_advancedSettings);
+ }
+
+ static const RdpClient * InnerToOuter(const SecuredSettings * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_securedSettings);
+ }
+
+ static const RdpClient * InnerToOuter(const RDPCLIENT * innerThis)
+ {
+ return CONTAINING_RECORD(innerThis, RdpClient, m_protocolState);
+ }
+
+ RdpClientUI * GetUI() const
+ {
+ assert(m_clientUI);
+ return m_clientUI;
+ }
+
+ /* Glue for rdesktop-core */
+public:
+ static bool OnPublicKey(RDPCLIENT * This, unsigned char * key, unsigned int key_size)
+ {
+ return InnerToOuter(This)->OnPublicKey(key, key_size);
+ }
+
+ static void OnLogon(RDPCLIENT * This)
+ {
+ return InnerToOuter(This)->OnLogon();
+ }
+
+ static bool OnRedirect
+ (
+ RDPCLIENT * This,
+ uint32 flags,
+ uint32 server_len,
+ wchar_t * server,
+ uint32 cookie_len,
+ char * cookie,
+ uint32 username_len,
+ wchar_t * username,
+ uint32 domain_len,
+ wchar_t * domain,
+ uint32 password_len,
+ wchar_t * password
+ )
+ {
+ return InnerToOuter(This)->OnRedirect
+ (
+ flags,
+ server_len,
+ server,
+ cookie_len,
+ cookie,
+ username_len,
+ username,
+ domain_len,
+ domain,
+ password_len,
+ password
+ );
+ }
+
+private:
+ bool OnPublicKey(unsigned char * key, unsigned int key_size)
+ {
+ HRESULT hr = FireReceivedTSPublicKey(key, key_size);
+
+ if(FAILED(hr))
+ {
+ m_protocolState.disconnect_reason = 262;
+ return false;
+ }
+
+ return hr == S_OK;
+ }
+
+ void OnLogon()
+ {
+ m_loggedIn = true;
+ FireLoginComplete();
+ }
+
+ bool OnRedirect
+ (
+ uint32 flags,
+ uint32 server_len,
+ wchar_t * server,
+ uint32 cookie_len,
+ char * cookie,
+ uint32 username_len,
+ wchar_t * username,
+ uint32 domain_len,
+ wchar_t * domain,
+ uint32 password_len,
+ wchar_t * password
+ )
+ {
+ assert(m_Connected);
+ assert(!InsideApartment());
+ assert(IsWindow(m_controlWindow));
+
+ RedirectArguments redirectArgs =
+ {
+ flags,
+ server_len,
+ server,
+ cookie_len,
+ cookie,
+ username_len,
+ username,
+ domain_len,
+ domain,
+ password_len,
+ password
+ };
+
+ return SendMessage(m_controlWindow, RDPC_WM_REDIRECT, 0, reinterpret_cast<LPARAM>(&redirectArgs)) == 0;
+ }
+
+private:
+ static DWORD WINAPI ProtocolLoopThreadProc(LPVOID lpParam)
+ {
+ static_cast<RdpClient *>(lpParam)->ProtocolLoop();
+ return 0;
+ }
+
+ static VOID CALLBACK ConnectionTimerAPC(LPVOID, DWORD, DWORD)
+ {
+ }
+
+ // FIXME: various potential inconsistencies due to lack of detailed documentation of expected semantics
+ void ProtocolLoop()
+ {
+ HANDLE waitingReconnection = NULL;
+
+ // Retrieve the local hostname to be passed to the server
+ WCHAR hostname[MAX_COMPUTERNAME_LENGTH + 1];
+ DWORD hostnameLen = ARRAYSIZE(hostname);
+
+ if(!GetComputerNameW(hostname, &hostnameLen))
+ hostname[0] = 0;
+
+ // Set some connection flags
+ uint32 flags = RDP_LOGON_NORMAL;
+
+ if(m_Compress)
+ flags |= RDP_LOGON_COMPRESSION | RDP_LOGON_COMPRESSION2;
+
+ if(m_AudioRedirectionMode == 1)
+ flags |= RDP_LOGON_LEAVE_AUDIO;
+
+ if(m_ClearTextPassword)
+ flags |= RDP_LOGON_AUTO;
+
+ // Notify the container that the connection process is beginning now
+ FireConnecting();
+
+ // Set the overall connection timer, if a timeout is set
+ // BUGBUG: the timeout semantics are ambiguous and have been most probably misinterpreted
+ HANDLE overallConnectionTimer = NULL;
+ LARGE_INTEGER overallTimeout;
+
+ if(m_overallConnectionTimeout)
+ {
+ overallTimeout.QuadPart = - ((m_overallConnectionTimeout * 1000 * 1000 * 1000) / 100);
+
+ overallConnectionTimer = CreateWaitableTimer(NULL, FALSE, NULL);
+
+ if(overallConnectionTimer == NULL)
+ goto l_Disconnect;
+ }
+
+ if(overallConnectionTimer)
+ SetWaitableTimer(overallConnectionTimer, &overallTimeout, 0, ConnectionTimerAPC, NULL, FALSE);
+
+ // Initial connection
+ BOOL disconnected = rdp_connect
+ (
+ &m_protocolState,
+ m_Server,
+ flags,
+ m_UserName,
+ m_Domain,
+ m_ClearTextPassword,
+ m_StartProgram,
+ m_WorkDir,
+ hostname,
+ m_LoadBalanceInfo
+ );
+
+ if(overallConnectionTimer)
+ CancelWaitableTimer(overallConnectionTimer);
+
+ if(disconnected)
+ goto l_Disconnect;
+
+ // TODO: set the disconnect reason for every instance in which we abort the loop
+ for(;;)
+ {
+ BOOL deactivated = False;
+ uint32 extendedDisconnectReason = 0;
+
+ m_actuallyConnected = true;
+
+ // Notify the container of the successful connection
+ FireConnected();
+
+ // Main protocol loop
+ m_loggedIn = false;
+ rdp_main_loop(&m_protocolState, &deactivated, &extendedDisconnectReason);
+ rdp_disconnect(&m_protocolState);
+
+ m_actuallyConnected = false;
+
+ // Redirection
+ // BUGBUG: redirection is very messy and probably this implementation is not "canonical"
+ if(m_protocolState.redirect)
+ {
+ m_protocolState.redirect = False;
+ rdp_reset_state(&m_protocolState);
+
+ // TODO: reset connection parameters
+ // This has to be done in the main thread, so use SendMessage on the control window
+
+ flags |= RDP_LOGON_AUTO;
+
+ // retry
+ continue;
+ }
+
+ // Disconnection
+ m_ExtendedDisconnectReason = static_cast<MSTSCLib::ExtendedDisconnectReasonCode>(extendedDisconnectReason);
+
+ // Clean disconnection
+ if(deactivated)
+ break;
+
+ BOOL success;
+
+ long autoReconnections = 0;
+ long totalReconnections = 0;
+
+ // Reconnection
+ // BUGBUG: reconnection semantics may not be entirely accurate
+ do
+ {
+ ++ totalReconnections;
+
+ // ask the container whether we should reconnect
+ long reconnectMode = FireAutoReconnecting(m_protocolState.disconnect_reason, totalReconnections);
+
+ // do not reconnect
+ if(reconnectMode == MSTSCLib::autoReconnectContinueStop)
+ goto l_Disconnect;
+
+ // the container will reconnect or abort manually
+ if(reconnectMode == MSTSCLib::autoReconnectContinueManual)
+ {
+ assert(!m_reconnectAborted);
+ assert(m_protocolThreadWaitingReconnection == NULL);
+
+ if(waitingReconnection == NULL)
+ {
+ waitingReconnection = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+ if(waitingReconnection == NULL)
+ // TODO: fatal error
+ goto l_Disconnect;
+ }
+
+ m_protocolThreadWaitingReconnection = waitingReconnection;
+
+ WaitForSingleObject(waitingReconnection, INFINITE);
+
+ m_protocolThreadWaitingReconnection = NULL;
+
+ if(m_reconnectAborted)
+ {
+ // FIXME? do we set the disconnection status here?
+ goto l_Disconnect;
+ }
+ }
+ // reconnect automatically
+ else
+ {
+ // automatic reconnection is disabled
+ if(m_EnableAutoReconnect)
+ break;
+
+ // too many consecutive automatic reconnections
+ if(autoReconnections == m_MaxReconnectAttempts)
+ break;
+
+ ++ autoReconnections;
+ }
+
+ if(overallConnectionTimer)
+ SetWaitableTimer(overallConnectionTimer, &overallTimeout, 0, ConnectionTimerAPC, NULL, FALSE);
+
+ // Reconnection
+ success = rdp_reconnect
+ (
+ &m_protocolState,
+ m_Server,
+ flags,
+ m_UserName,
+ m_Domain,
+ m_ClearTextPassword,
+ m_StartProgram,
+ m_WorkDir,
+ hostname,
+ m_LoadBalanceInfo
+ );
+
+ if(overallConnectionTimer)
+ CancelWaitableTimer(overallConnectionTimer);
+ }
+ while(!success);
+ }
+
+l_Disconnect:
+ // Disconnected
+ FireDisconnected(m_protocolState.disconnect_reason);
+
+ if(overallConnectionTimer)
+ CloseHandle(overallConnectionTimer);
+ }
+
+ void JoinProtocolThread()
+ {
+ assert(m_protocolThread);
+ WaitForSingleObject(m_protocolThread, INFINITE);
+ CloseHandle(m_protocolThread);
+ m_protocolThread = NULL;
+ }
+
+ void TerminateProtocolThread()
+ {
+ assert(m_protocolThread);
+
+ // wake it up if it's waiting for a manual reconnection
+ if(m_protocolThreadWaitingReconnection)
+ {
+ assert(!m_reconnectAborted);
+ m_reconnectAborted = true;
+ SetEvent(m_protocolThreadWaitingReconnection);
+ }
+ // otherwise, attempt to interrupt any current blocking operation
+ else
+ {
+ // shutdown(m_protocolState.tcp.sock, SD_BOTH); // TBD: maybe in the future?
+ QueueUserAPC(DisconnectAPC, m_protocolThread, 0);
+ }
+
+ assert(m_protocolThreadWaitingReconnection == NULL);
+ }
+
+ void PerformDisconnect(long reason)
+ {
+ assert(InsideApartment());
+ assert(m_Connected);
+
+ // TODO: notify virtual channels
+
+ // TODO: do any other disconnection work here...
+
+ // Put the control in the disconnected state
+ m_Connected = false;
+ m_loggedIn = false;
+
+ // Notify the container
+ VARIANTARG arg = { };
+
+ arg.vt = VT_I4;
+ arg.lVal = reason;
+
+ FireEventInsideApartment(4, &arg, 1);
+ }
+
+public:
+ /* Startup initialization */
+ static BOOL Startup()
+ {
+ if(!RdpClientUI::Startup())
+ return FALSE;
+
+ WNDCLASSEX wcex = { sizeof(wcex) };
+
+ wcex.style = CS_HREDRAW | CS_VREDRAW;
+ wcex.lpfnWndProc = ControlWindowProc;
+ wcex.hInstance = GetCurrentModule();
+ wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+ wcex.lpszClassName = TEXT("MissTosca_Control");
+
+ return RegisterClassEx(&wcex);
+ }
+
+ static void Shutdown()
+ {
+ UnregisterClass(TEXT("MissTosca_Control"), GetCurrentModule());
+ }
+
+ /* Class factory */
+ static HRESULT CreateInstance(REFCLSID rclsid, unsigned libIndex, IUnknown * punkOuter, REFIID riid, void ** ppObj)
+ {
+ RdpClient * obj = new RdpClient(rclsid, libIndex, punkOuter);
+
+ if(obj == NULL)
+ return E_OUTOFMEMORY;
+
+ HRESULT hr = obj->m_inner.QueryInterface(riid, ppObj);
+
+ if(FAILED(hr))
+ {
+ delete obj;
+ return hr;
+ }
+
+ assert(obj->m_refCount == 1);
+ assert(*ppObj != NULL);
+
+ return S_OK;
+ }
+
+private:
+ /* Connection point enumerator */
+ class CEnumConnectionPoints: public IEnumConnectionPoints
+ {
+ private:
+ LONG m_refCount;
+ IConnectionPoint * m_cp;
+ bool m_done;
+
+ public:
+ CEnumConnectionPoints(IConnectionPoint * cp): m_refCount(1), m_cp(cp), m_done(false)
+ {
+ assert(m_cp);
+ m_cp->AddRef();
+ }
+
+ CEnumConnectionPoints(const CEnumConnectionPoints& ecp): m_refCount(1), m_cp(ecp.m_cp), m_done(ecp.m_done)
+ {
+ assert(m_cp);
+ m_cp->AddRef();
+ }
+
+ ~CEnumConnectionPoints()
+ {
+ assert(m_cp);
+ m_cp->Release();
+ }
+
+ virtual STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ if(riid == IID_IUnknown || riid == IID_IEnumConnectionPoints)
+ {
+ *ppvObject = this;
+ return S_OK;
+ }
+ else
+ {
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+ }
+
+ virtual STDMETHODIMP_(ULONG) AddRef()
+ {
+ return InterlockedIncrement(&m_refCount);
+ }
+
+ virtual STDMETHODIMP_(ULONG) Release()
+ {
+ LONG n = InterlockedDecrement(&m_refCount);
+
+ if(n == 0)
+ delete this;
+
+ return n;
+ }
+
+ virtual STDMETHODIMP Next(ULONG cConnections, LPCONNECTIONPOINT * ppCP, ULONG * pcFetched)
+ {
+ if(cConnections == 0 || m_done)
+ return S_FALSE;
+
+ m_done = true;
+ m_cp->AddRef();
+ *ppCP = m_cp;
+ *pcFetched = 1;
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP Skip(ULONG cConnections)
+ {
+ if(cConnections == 0)
+ return S_OK;
+
+ if(cConnections == 1 && !m_done)
+ {
+ m_done = true;
+ return S_OK;
+ }
+
+ assert(cConnections > 1 || m_done);
+
+ return S_FALSE;
+ }
+
+ virtual STDMETHODIMP Reset()
+ {
+ m_done = false;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP Clone(IEnumConnectionPoints ** ppEnum)
+ {
+ if(ppEnum == NULL)
+ return E_POINTER;
+
+ *ppEnum = new CEnumConnectionPoints(*this);
+
+ if(*ppEnum == NULL)
+ return E_OUTOFMEMORY;
+
+ return S_OK;
+ }
+ };
+
+ /* Pay no attention, ActiveX glue... */
+ LRESULT ControlWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ switch(uMsg)
+ {
+ case WM_SIZE:
+ {
+ // TODO: resize UI
+ }
+
+ return 0;
+
+ case WM_PAINT:
+ {
+ LPCWSTR text = NULL;
+
+ if(!m_Connected)
+ text = m_DisconnectedText;
+ else if(m_actuallyConnected)
+ text = m_ConnectedStatusText;
+ else
+ text = m_ConnectingText;
+
+ RECT clientRect;
+ GetClientRect(m_controlWindow, &clientRect);
+
+ PAINTSTRUCT ps;
+ HDC hdc = BeginPaint(m_controlWindow, &ps);
+
+ SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
+ SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
+ SelectObject(hdc, GetStockObject(SYSTEM_FONT));
+
+ RECT textRect = clientRect;
+
+ DrawTextW
+ (
+ hdc,
+ text,
+ -1,
+ &textRect,
+ DT_CENTER | DT_EDITCONTROL | DT_END_ELLIPSIS | DT_NOPREFIX | DT_WORDBREAK | DT_CALCRECT
+ );
+
+ if(textRect.right > clientRect.right)
+ textRect.right = clientRect.right;
+
+ if(textRect.bottom > clientRect.bottom)
+ textRect.bottom = clientRect.bottom;
+
+ textRect.left = (clientRect.right - textRect.right) / 2;
+ textRect.right += textRect.left;
+ textRect.top = (clientRect.bottom - textRect.bottom) / 2;
+ textRect.bottom += textRect.top;
+
+ DrawTextW
+ (
+ hdc,
+ text,
+ -1,
+ &textRect,
+ DT_CENTER | DT_EDITCONTROL | DT_END_ELLIPSIS | DT_NOPREFIX | DT_WORDBREAK
+ );
+
+ EndPaint(m_controlWindow, &ps);
+ }
+
+ return 0;
+
+ default:
+ {
+ LRESULT result;
+
+ if(HandleEvent(uMsg, wParam, lParam, result))
+ return result;
+ }
+
+ break;
+ }
+
+ return DefWindowProc(m_controlWindow, uMsg, wParam, lParam);
+ }
+
+ static LRESULT CALLBACK ControlWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+ {
+ if(uMsg == WM_CREATE)
+ {
+ SetWindowLongPtr
+ (
+ hwnd,
+ GWLP_USERDATA,
+ (LONG_PTR)reinterpret_cast<LPCREATESTRUCT>(lParam)->lpCreateParams
+ );
+ }
+
+ RdpClient * Self = reinterpret_cast<RdpClient *>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
+ assert(Self);
+
+ return Self->ControlWindowProc(uMsg, wParam, lParam);
+ }
+
+ HRESULT CreateControlWindow(HWND hwndParent)
+ {
+ m_controlWindow = CreateWindow
+ (
+ TEXT("MissTosca_Control"),
+ NULL,
+ WS_CHILD | WS_CLIPCHILDREN,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ hwndParent,
+ NULL,
+ GetCurrentModule(),
+ this
+ );
+
+ if(m_controlWindow == NULL)
+ return HRESULT_FROM_WIN32(GetLastError());
+
+ m_UIParentWindowHandle = m_controlWindow;
+ return S_OK;
+ }
+
+ HRESULT DestroyControlWindow()
+ {
+ if(m_controlWindow == NULL)
+ return S_FALSE;
+
+ HWND controlWindow = NULL;
+ std::swap(controlWindow, m_controlWindow);
+ DestroyWindow(controlWindow);
+ return S_OK;
+ }
+
+ HRESULT Activate(LONG iVerb, IOleClientSite * pActiveSite, HWND hwndParent, LPCRECT lprcPosRect)
+ {
+ if(pActiveSite == NULL)
+ pActiveSite = m_clientSite;
+
+ if(pActiveSite == NULL)
+ return E_FAIL;
+
+ // TODO: store this until we are closed or deactivated
+ IOleInPlaceSite * site;
+
+ HRESULT hr = pActiveSite->QueryInterface(&site);
+
+ if(FAILED(hr))
+ return hr;
+
+ IOleInPlaceFrame * frame = NULL;
+ IOleInPlaceUIWindow * uiWindow = NULL;
+
+ for(;;)
+ {
+ hr = site->CanInPlaceActivate();
+
+ if(hr == S_FALSE)
+ hr = E_FAIL;
+
+ if(FAILED(hr))
+ break;
+
+ site->OnInPlaceActivate();
+
+ if(hwndParent == NULL)
+ {
+ hr = site->GetWindow(&hwndParent);
+
+ if(FAILED(hr))
+ break;
+ }
+
+ RECT rcPos;
+ RECT rcClip;
+ OLEINPLACEFRAMEINFO frameInfo = { sizeof(frameInfo) };
+
+ site->GetWindowContext(&frame, &uiWindow, &rcPos, &rcClip, &frameInfo);
+
+ if(lprcPosRect == NULL)
+ lprcPosRect = &rcPos;
+
+ if(m_controlWindow)
+ ShowWindow(m_controlWindow, SW_SHOW);
+ else
+ {
+ hr = CreateControlWindow(hwndParent);
+
+ if(FAILED(hr))
+ break;
+ }
+
+ SetObjectRects(lprcPosRect, &rcClip);
+
+ // UI activation
+ if((iVerb == OLEIVERB_PRIMARY || iVerb == OLEIVERB_UIACTIVATE) && !m_uiActive)
+ {
+ m_uiActive = true;
+
+ hr = site->OnUIActivate();
+
+ if(FAILED(hr))
+ break;
+
+ SetWindowPos
+ (
+ m_controlWindow,
+ NULL,
+ lprcPosRect->left,
+ lprcPosRect->top,
+ lprcPosRect->right - lprcPosRect->left,
+ lprcPosRect->bottom - lprcPosRect->top,
+ SWP_SHOWWINDOW
+ );
+
+ if(frame)
+ {
+ frame->SetActiveObject(this, NULL);
+ frame->SetBorderSpace(NULL);
+ }
+
+ if(uiWindow)
+ {
+ uiWindow->SetActiveObject(this, NULL);
+ uiWindow->SetBorderSpace(NULL);
+ }
+ }
+
+ break;
+ }
+
+ if(uiWindow)
+ uiWindow->Release();
+
+ if(frame)
+ frame->Release();
+
+ site->Release();
+
+ if(SUCCEEDED(hr))
+ pActiveSite->ShowObject();
+
+ return hr;
+ }
+
+public:
+ /* IUnknown */
+ /*
+ NOTE: this is the delegating implementation, to support aggregation. The actual
+ implementation is RdpClientInner, above
+ */
+ virtual STDMETHODIMP IUnknown::QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ return m_punkOuter->QueryInterface(riid, ppvObject);
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::AddRef()
+ {
+ return m_punkOuter->AddRef();
+ }
+
+ virtual STDMETHODIMP_(ULONG) IUnknown::Release()
+ {
+ return m_punkOuter->Release();
+ }
+
+ /* IDispatch */
+ virtual STDMETHODIMP IDispatch::GetTypeInfoCount(UINT * pctinfo)
+ {
+ *pctinfo = 1;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IDispatch::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo ** ppTInfo)
+ {
+ if(iTInfo != 0)
+ return DISP_E_BADINDEX;
+
+ return AcquireDispTypeInfo(ppTInfo);
+ }
+
+ virtual STDMETHODIMP IDispatch::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
+ {
+ HRESULT hr = LoadDispTypeInfo();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_dispTypeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId);
+ }
+
+ virtual STDMETHODIMP IDispatch::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult, EXCEPINFO * pExcepInfo, UINT * puArgErr)
+ {
+ HRESULT hr = LoadDispTypeInfo();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_dispTypeInfo->Invoke
+ (
+ static_cast<MSTSCLib::IMsRdpClient4 *>(this),
+ dispIdMember,
+ wFlags,
+ pDispParams,
+ pVarResult,
+ pExcepInfo,
+ puArgErr
+ );
+ }
+
+ /* IConnectionPoint */
+ virtual STDMETHODIMP GetConnectionInterface(IID * pIID)
+ {
+ if(pIID == NULL)
+ return E_POINTER;
+
+ *pIID = MSTSCLib::DIID_IMsTscAxEvents;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP GetConnectionPointContainer(IConnectionPointContainer ** ppCPC)
+ {
+ if(ppCPC == NULL)
+ return E_POINTER;
+
+ addRef();
+ *ppCPC = this;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP Advise(IUnknown * pUnkSink, DWORD * pdwCookie)
+ {
+ MSTSCLib::IMsTscAxEvents * sink;
+
+ if(FAILED(pUnkSink->QueryInterface(&sink)))
+ return CONNECT_E_CANNOTCONNECT;
+
+ MSTSCLib::IMsTscAxEvents ** sinks = GetSinks();
+ DWORD cookie = 0;
+
+ if(m_EventSinksCount)
+ {
+ bool found = false;
+
+ for(size_t i = 0; i < m_EventSinksCount; ++ i)
+ {
+ found = (sinks[i] == NULL);
+
+ if(found)
+ {
+ cookie = static_cast<DWORD>(i);
+ break;
+ }
+ }
+
+ if(!found)
+ {
+ MSTSCLib::IMsTscAxEvents ** newSinks = new MSTSCLib::IMsTscAxEvents *[m_EventSinksCount + 1];
+
+ if(newSinks == NULL)
+ {
+ sink->Release();
+ return E_OUTOFMEMORY;
+ }
+
+ std::copy(sinks, sinks + m_EventSinksCount, newSinks);
+
+ m_EventSinks = newSinks;
+ sinks = newSinks;
+
+ cookie = static_cast<DWORD>(m_EventSinksCount);
+ }
+ }
+
+ sinks[cookie] = sink;
+ *pdwCookie = cookie;
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP Unadvise(DWORD dwCookie)
+ {
+ MSTSCLib::IMsTscAxEvents ** sinks = GetSinks();
+
+ if(dwCookie >= m_EventSinksCount || sinks[dwCookie] == NULL)
+ return CONNECT_E_NOCONNECTION;
+
+ sinks[dwCookie]->Release();
+ sinks[dwCookie] = NULL;
+
+ // BUGBUG: the array currently grows forever. Trim it whenever possible
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP EnumConnections(IEnumConnections ** ppEnum)
+ {
+ // I see no real value in this
+ return E_NOTIMPL;
+ }
+
+ /* IConnectionPointContainer */
+ virtual STDMETHODIMP IConnectionPointContainer::EnumConnectionPoints(IEnumConnectionPoints ** ppEnum)
+ {
+ *ppEnum = new CEnumConnectionPoints(this);
+
+ if(*ppEnum == NULL)
+ return E_OUTOFMEMORY;
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IConnectionPointContainer::FindConnectionPoint(REFIID riid, IConnectionPoint ** ppCP)
+ {
+ if(riid != MSTSCLib::DIID_IMsTscAxEvents)
+ return CONNECT_E_NOCONNECTION;
+
+ addRef();
+ *ppCP = this;
+
+ return S_OK;
+ }
+
+ /* IDataObject */ // 0/9
+ virtual STDMETHODIMP IDataObject::GetData(FORMATETC * pformatetcIn, STGMEDIUM * pmedium)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IDataObject::GetDataHere(FORMATETC * pformatetc, STGMEDIUM * pmedium)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IDataObject::QueryGetData(FORMATETC * pformatetc)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IDataObject::GetCanonicalFormatEtc(FORMATETC * pformatectIn, FORMATETC * pformatetcOut)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IDataObject::SetData(FORMATETC * pformatetc, STGMEDIUM * pmedium, BOOL fRelease)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IDataObject::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC ** ppenumFormatEtc)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IDataObject::DAdvise(FORMATETC * pformatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IDataObject::DUnadvise(DWORD dwConnection)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IDataObject::EnumDAdvise(IEnumSTATDATA ** ppenumAdvise)
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IObjectSafety */
+ virtual STDMETHODIMP IObjectSafety::GetInterfaceSafetyOptions(REFIID riid, DWORD * pdwSupportedOptions, DWORD * pdwEnabledOptions)
+ {
+ if(pdwSupportedOptions == NULL || pdwEnabledOptions == NULL)
+ return E_POINTER;
+
+ if(riid != IID_IDispatch)
+ return E_NOINTERFACE;
+
+ *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_CALLER;
+ *pdwEnabledOptions = m_SafetyOptions;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IObjectSafety::SetInterfaceSafetyOptions(REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions)
+ {
+ if(riid != IID_IDispatch)
+ return E_NOINTERFACE;
+
+ m_SafetyOptions = dwEnabledOptions & (dwOptionSetMask & INTERFACESAFE_FOR_UNTRUSTED_CALLER);
+ return S_OK;
+ }
+
+ /* IOleControl */ // 3/4
+ virtual STDMETHODIMP IOleControl::GetControlInfo(CONTROLINFO * pCI)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleControl::OnMnemonic(MSG * pMsg)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleControl::OnAmbientPropertyChange(DISPID dispID)
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleControl::FreezeEvents(BOOL bFreeze)
+ {
+ if(bFreeze)
+ InterlockedIncrement(&m_freezeEvents);
+ else if(InterlockedDecrement(&m_freezeEvents) == 0)
+ UnfreezeEvents();
+
+ return S_OK;
+ }
+
+ /* IOleInPlaceActiveObject */ // 3/5
+ virtual STDMETHODIMP IOleInPlaceActiveObject::TranslateAccelerator(LPMSG lpmsg)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceActiveObject::OnFrameWindowActivate(BOOL fActivate)
+ {
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceActiveObject::OnDocWindowActivate(BOOL fActivate)
+ {
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceActiveObject::ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow * pUIWindow, BOOL fFrameWindow)
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceActiveObject::EnableModeless(BOOL fEnable)
+ {
+ return S_OK;
+ }
+
+ /* IOleInPlaceObject */ // 1/4
+ virtual STDMETHODIMP IOleInPlaceObject::InPlaceDeactivate()
+ {
+ // TODO: UIDeactivate, destroy window, inplacesite->OnInPlaceDeactivate
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceObject::UIDeactivate()
+ {
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceObject::SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect)
+ {
+ if(m_controlWindow == NULL)
+ return E_FAIL;
+
+ MoveWindow
+ (
+ m_controlWindow,
+ lprcPosRect->left,
+ lprcPosRect->top,
+ lprcPosRect->right - lprcPosRect->left,
+ lprcPosRect->bottom - lprcPosRect->top,
+ TRUE
+ );
+
+ SetWindowRgn(m_controlWindow, CreateRectRgnIndirect(lprcClipRect), TRUE);
+
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleInPlaceObject::ReactivateAndUndo()
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IOleObject */ // 18/21
+ virtual STDMETHODIMP IOleObject::SetClientSite(IOleClientSite * pClientSite)
+ {
+ if(m_clientSite)
+ m_clientSite->Release();
+
+ m_clientSite = pClientSite;
+
+ if(m_clientSite)
+ m_clientSite->AddRef();
+
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetClientSite(IOleClientSite ** ppClientSite)
+ {
+ if(ppClientSite == NULL)
+ return E_POINTER;
+
+ if(m_clientSite)
+ m_clientSite->AddRef();
+
+ *ppClientSite = m_clientSite;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::Close(DWORD dwSaveOption)
+ {
+ // TODO: deactivate, destroy window, release in-place site, release advise sink
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IOleObject::SetMoniker(DWORD dwWhichMoniker, IMoniker * pmk)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker ** ppmk)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleObject::InitFromData(IDataObject * pDataObject, BOOL fCreation, DWORD dwReserved)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetClipboardData(DWORD dwReserved, IDataObject ** ppDataObject)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleObject::DoVerb(LONG iVerb, LPMSG lpmsg, IOleClientSite * pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
+ {
+ HRESULT hr;
+
+ switch(iVerb)
+ {
+ case OLEIVERB_PRIMARY:
+ case OLEIVERB_SHOW:
+ case OLEIVERB_UIACTIVATE:
+ case OLEIVERB_INPLACEACTIVATE:
+ hr = S_OK;
+ break;
+
+ default:
+ if(iVerb > 0)
+ hr = OLEOBJ_S_INVALIDVERB;
+ else
+ hr = E_NOTIMPL;
+ }
+
+ if(FAILED(hr))
+ return hr;
+
+ HRESULT hrActivate = Activate(iVerb, pActiveSite, hwndParent, lprcPosRect);
+
+ if(FAILED(hrActivate))
+ hr = hrActivate;
+
+ return hr;
+ }
+
+ virtual STDMETHODIMP IOleObject::EnumVerbs(IEnumOLEVERB ** ppEnumOleVerb)
+ {
+ return OleRegEnumVerbs(m_classId, ppEnumOleVerb);
+ }
+
+ virtual STDMETHODIMP IOleObject::Update()
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::IsUpToDate()
+ {
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetUserClassID(CLSID * pClsid)
+ {
+ *pClsid = m_classId;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetUserType(DWORD dwFormOfType, LPOLESTR * pszUserType)
+ {
+ return OleRegGetUserType(m_classId, dwFormOfType, pszUserType);
+ }
+
+ virtual STDMETHODIMP IOleObject::SetExtent(DWORD dwDrawAspect, SIZEL * psizel)
+ {
+ // TODO: resize
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IOleObject::GetExtent(DWORD dwDrawAspect, SIZEL * psizel)
+ {
+ // TODO: return size
+ return E_NOTIMPL;
+ }
+
+ HRESULT NeedAdviseHolder()
+ {
+ if(m_adviseHolder)
+ return S_OK;
+
+ return CreateOleAdviseHolder(&m_adviseHolder);
+ }
+
+ virtual STDMETHODIMP IOleObject::Advise(IAdviseSink * pAdvSink, DWORD * pdwConnection)
+ {
+ HRESULT hr = NeedAdviseHolder();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_adviseHolder->Advise(pAdvSink, pdwConnection);
+ }
+
+ virtual STDMETHODIMP IOleObject::Unadvise(DWORD dwConnection)
+ {
+ HRESULT hr = NeedAdviseHolder();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_adviseHolder->Unadvise(dwConnection);
+ }
+
+ virtual STDMETHODIMP IOleObject::EnumAdvise(IEnumSTATDATA ** ppenumAdvise)
+ {
+ HRESULT hr = NeedAdviseHolder();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_adviseHolder->EnumAdvise(ppenumAdvise);
+ }
+
+ virtual STDMETHODIMP IOleObject::GetMiscStatus(DWORD dwAspect, DWORD * pdwStatus)
+ {
+ return OleRegGetMiscStatus(m_classId, dwAspect, pdwStatus);
+ }
+
+ virtual STDMETHODIMP IOleObject::SetColorScheme(LOGPALETTE * pLogpal)
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IOleWindow */
+ virtual STDMETHODIMP IOleWindow::GetWindow(HWND * phwnd)
+ {
+ if(phwnd == NULL)
+ return E_POINTER;
+
+ if(m_controlWindow == NULL)
+ return E_FAIL;
+
+ *phwnd = m_controlWindow;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IOleWindow::ContextSensitiveHelp(BOOL fEnterMode)
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IPersist */
+ virtual STDMETHODIMP IPersist::GetClassID(CLSID * pClassID)
+ {
+ *pClassID = m_classId;
+ return S_OK;
+ }
+
+ /* IPersistPropertyBag */ // 0/3
+ virtual STDMETHODIMP IPersistPropertyBag::InitNew()
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistPropertyBag::Load(IPropertyBag * pPropBag, IErrorLog * pErrorLog)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistPropertyBag::Save(IPropertyBag * pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties)
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IPersistStorage */ // 0/6
+ virtual STDMETHODIMP IPersistStorage::IsDirty()
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStorage::InitNew(IStorage * pStg)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStorage::Load(IStorage * pStg)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStorage::Save(IStorage * pStgSave, BOOL fSameAsLoad)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStorage::SaveCompleted(IStorage * pStgNew)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStorage::HandsOffStorage()
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IPersistStreamInit */ // 0/5
+ virtual STDMETHODIMP IPersistStreamInit::IsDirty()
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStreamInit::Load(LPSTREAM pStm)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStreamInit::Save(LPSTREAM pStm, BOOL fClearDirty)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStreamInit::GetSizeMax(ULARGE_INTEGER * pCbSize)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IPersistStreamInit::InitNew()
+ {
+ return E_NOTIMPL;
+ }
+
+ /* IProvideClassInfo */
+ virtual STDMETHODIMP IProvideClassInfo::GetClassInfo(ITypeInfo ** ppTI)
+ {
+ HRESULT hr = LoadTypeLibrary();
+
+ if(FAILED(hr))
+ return hr;
+
+ return m_typeLib->GetTypeInfoOfGuid(m_classId, ppTI);
+ }
+
+ /* IProvideClassInfo2 */
+ virtual STDMETHODIMP IProvideClassInfo2::GetGUID(DWORD dwGuidKind, GUID * pGUID)
+ {
+ if(dwGuidKind != GUIDKIND_DEFAULT_SOURCE_DISP_IID)
+ return E_INVALIDARG;
+
+ *pGUID = MSTSCLib::DIID_IMsTscAxEvents;
+ return S_OK;
+ }
+
+ /* IQuickActivate */
+ virtual STDMETHODIMP IQuickActivate::QuickActivate(QACONTAINER * pQaContainer, QACONTROL * pQaControl)
+ {
+ if(pQaContainer == NULL || pQaControl == NULL)
+ return E_POINTER;
+
+ if(pQaContainer->cbSize < sizeof(*pQaContainer) || pQaControl->cbSize < sizeof(*pQaControl))
+ return E_INVALIDARG;
+
+ ULONG cb = pQaControl->cbSize;
+ ZeroMemory(pQaControl, cb);
+ pQaControl->cbSize = cb;
+
+ SetClientSite(pQaContainer->pClientSite);
+
+ if(pQaContainer->pAdviseSink)
+ SetAdvise(DVASPECT_CONTENT, 0, pQaContainer->pAdviseSink);
+
+ if(pQaContainer->pUnkEventSink)
+ Advise(pQaContainer->pUnkEventSink, &pQaControl->dwEventCookie);
+
+ GetMiscStatus(DVASPECT_CONTENT, &pQaControl->dwMiscStatus);
+
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IQuickActivate::SetContentExtent(LPSIZEL pSizel)
+ {
+ return SetExtent(DVASPECT_CONTENT, pSizel);
+ }
+
+ virtual STDMETHODIMP IQuickActivate::GetContentExtent(LPSIZEL pSizel)
+ {
+ return GetExtent(DVASPECT_CONTENT, pSizel);
+ }
+
+ /* IViewObject */ // 3/6
+ virtual STDMETHODIMP IViewObject::Draw(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DVTARGETDEVICE * ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL (STDMETHODCALLTYPE * pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IViewObject::GetColorSet(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DVTARGETDEVICE * ptd, HDC hicTargetDev, LOGPALETTE ** ppColorSet)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IViewObject::Freeze(DWORD dwDrawAspect, LONG lindex, void * pvAspect, DWORD * pdwFreeze)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IViewObject::Unfreeze(DWORD dwFreeze)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IViewObject::SetAdvise(DWORD aspects, DWORD advf, IAdviseSink * pAdvSink)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IViewObject::GetAdvise(DWORD * pAspects, DWORD * pAdvf, IAdviseSink ** ppAdvSink)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ /* IViewObject2 */ // 0/1
+ virtual STDMETHODIMP IViewObject2::GetExtent(DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE * ptd, LPSIZEL lpsizel)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ /* IMsTscAx */ // 23/30
+ virtual STDMETHODIMP IMsTscAx::put_Server(BSTR pServer)
+ {
+ // FIXME: convert the hostname to Punycode, not the ANSI codepage
+ return SetProperty(m_Server, pServer);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Server(BSTR * pServer) const
+ {
+ return GetProperty(m_Server, pServer);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_Domain(BSTR pDomain)
+ {
+ return SetProperty(m_Domain, pDomain);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Domain(BSTR * pDomain) const
+ {
+ return GetProperty(m_Domain, pDomain);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_UserName(BSTR pUserName)
+ {
+ return SetProperty(m_UserName, pUserName);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_UserName(BSTR * pUserName) const
+ {
+ return GetProperty(m_UserName, pUserName);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_DisconnectedText(BSTR pDisconnectedText)
+ {
+ return SetProperty(m_DisconnectedText, pDisconnectedText);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_DisconnectedText(BSTR * pDisconnectedText) const
+ {
+ return GetProperty(m_DisconnectedText, pDisconnectedText);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_ConnectingText(BSTR pConnectingText)
+ {
+ return SetProperty(m_ConnectingText, pConnectingText);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_ConnectingText(BSTR * pConnectingText) const
+ {
+ return GetProperty(m_ConnectingText, pConnectingText);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Connected(short * pIsConnected) const
+ {
+ return GetProperty(m_Connected, pIsConnected);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_DesktopWidth(long pVal)
+ {
+ if(pVal < 200 || pVal > 1600)
+ return E_INVALIDARG;
+
+ return SetProperty(m_DesktopWidth, pVal);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_DesktopWidth(long * pVal) const
+ {
+ return GetProperty(m_DesktopWidth, pVal);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_DesktopHeight(long pVal)
+ {
+ if(pVal < 200 || pVal > 1200)
+ return E_INVALIDARG;
+
+ return SetProperty(m_DesktopHeight, pVal);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_DesktopHeight(long * pVal) const
+ {
+ return GetProperty(m_DesktopHeight, pVal);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_StartConnected(long pfStartConnected)
+ {
+ return SetProperty(m_StartConnected, pfStartConnected);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_StartConnected(long * pfStartConnected) const
+ {
+ return GetProperty(m_StartConnected, pfStartConnected);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_HorizontalScrollBarVisible(long * pfHScrollVisible) const
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_VerticalScrollBarVisible(long * pfVScrollVisible) const
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsTscAx::put_FullScreenTitle(BSTR rhs)
+ {
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_CipherStrength(long * pCipherStrength) const
+ {
+ if(pCipherStrength == NULL)
+ return E_INVALIDARG;
+
+ *pCipherStrength = 128; // BUGBUG: a later version may change this. Use a compile-time constant
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Version(BSTR * pVersion) const
+ {
+ if(pVersion == NULL)
+ return E_INVALIDARG;
+
+ BSTR version = SysAllocString(L"5.2.3790.1830"); // BUGBUG: don't use hardcoded string
+
+ if(version == NULL)
+ return E_OUTOFMEMORY;
+
+ *pVersion = version;
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_SecuredSettingsEnabled(long * pSecuredSettingsEnabled) const
+ {
+ // TODO: initialize m_SecuredSettingsEnabled as soon as we have an OLE client site
+ return GetProperty(m_SecuredSettingsEnabled, pSecuredSettingsEnabled);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_SecuredSettings(MSTSCLib::IMsTscSecuredSettings ** ppSecuredSettings) const
+ {
+ return GetSecuredSettings(ppSecuredSettings);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_AdvancedSettings(MSTSCLib::IMsTscAdvancedSettings ** ppAdvSettings) const
+ {
+ return GetAdvancedSettings(ppAdvSettings);
+ }
+
+ virtual STDMETHODIMP IMsTscAx::get_Debugger(MSTSCLib::IMsTscDebug ** ppDebugger) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::Connect()
+ {
+ if(m_Connected)
+ {
+ // Protocol thread waiting for a manual reconnection: wake it up
+ if(m_protocolThreadWaitingReconnection)
+ {
+ SetEvent(m_protocolThreadWaitingReconnection);
+ return S_OK;
+ }
+
+ return E_FAIL;
+ }
+
+ m_Connected = true;
+
+ HRESULT hr;
+
+ if(m_controlWindow == NULL)
+ {
+ hr = CreateControlWindow(NULL);
+
+ if(FAILED(hr))
+ return hr;
+ }
+
+ for(;;)
+ {
+ // TODO: initialize plugin DLLs/channels
+
+ m_clientUI = new RdpClientUI();
+
+ if(m_clientUI == NULL)
+ {
+ hr = E_OUTOFMEMORY;
+ break;
+ }
+
+ m_clientUI->Initialize(m_controlWindow);
+
+ m_protocolState.licence_username = BstrToLpsz(m_UserName);
+
+ if(m_protocolState.licence_username == NULL)
+ {
+ hr = E_OUTOFMEMORY;
+ break;
+ }
+
+ DWORD dwSize = ARRAYSIZE(m_protocolState.licence_hostname);
+
+ if(!GetComputerNameA(m_protocolState.licence_hostname, &dwSize))
+ {
+ hr = HRESULT_FROM_WIN32(GetLastError());
+ break;
+ }
+
+ // Keyboard layout
+ // BUGBUG: not too sure about the semantics
+ long keyboardLayout = -1;
+ WCHAR * endPtr = NULL;
+
+ if(m_KeyboardLayoutString)
+ keyboardLayout = wcstol(m_KeyboardLayoutString, &endPtr, 0);
+
+ // no keyboard layout specified or invalid keyboard layout: use current keyboard layout
+ if(endPtr == NULL || *endPtr == 0 || keyboardLayout == -1)
+ keyboardLayout = PtrToLong(GetKeyboardLayout(0)); // FIXME? use LOWORD()?
+
+ m_protocolState.keylayout = keyboardLayout;
+
+ // in case of failure, assume English (US)
+ if(m_protocolState.keylayout == 0)
+ m_protocolState.keylayout = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
+
+ // Physical keyboard information
+ m_protocolState.keyboard_type = GetKeyboardType(0);
+ m_protocolState.keyboard_subtype = GetKeyboardType(1);
+ m_protocolState.keyboard_functionkeys = GetKeyboardType(2);
+
+ // in case of failure, assume an IBM Enhanced keyboard with 12 function keys
+ if(m_protocolState.keyboard_type == 0 || m_protocolState.keyboard_functionkeys == 0)
+ {
+ m_protocolState.keyboard_type = 4;
+ m_protocolState.keyboard_subtype = 0;
+ m_protocolState.keyboard_functionkeys = 12;
+ }
+
+ // More initialization
+ m_protocolState.width = m_DesktopWidth;
+ m_protocolState.height = m_DesktopHeight;
+ m_protocolState.server_depth = m_ColorDepth;
+ m_protocolState.bitmap_compression = m_Compress ? TRUE : FALSE;
+ m_protocolState.bitmap_cache = True; // TODO
+ m_protocolState.bitmap_cache_persist_enable = False; // TODO
+ m_protocolState.bitmap_cache_precache = True; // FIXME?
+ m_protocolState.encryption = m_EncryptionEnabled ? TRUE : FALSE; // TBD: detect automatically
+ m_protocolState.packet_encryption = m_EncryptionEnabled ? TRUE : FALSE;
+ m_protocolState.desktop_save = True; // FIXME? tie to bitmap cache setting?
+ m_protocolState.polygon_ellipse_orders = True;
+ m_protocolState.use_rdp5 = True; // TBD: detect automatically
+ m_protocolState.console_session = m_ConnectToServerConsole ? TRUE : FALSE;
+ m_protocolState.rdp5_performanceflags = m_PerformanceFlags;
+ m_protocolState.tcp_port_rdp = m_RDPPort;
+ m_protocolState.rdp.current_status = 1;
+
+ // TODO: cache tuning based on the provided parameters
+
+ m_protocolState.cache.bmpcache_lru[0] = -1;
+ m_protocolState.cache.bmpcache_lru[1] = -1;
+ m_protocolState.cache.bmpcache_lru[2] = -1;
+ m_protocolState.cache.bmpcache_mru[0] = -1;
+ m_protocolState.cache.bmpcache_mru[1] = -1;
+ m_protocolState.cache.bmpcache_mru[2] = -1;
+
+ DWORD dwIgnore;
+ m_protocolThread = CreateThread(NULL, 0, ProtocolLoopThreadProc, this, 0, &dwIgnore);
+
+ hr = S_OK;
+ break;
+ }
+
+ if(FAILED(hr))
+ m_Connected = false;
+
+ return hr;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::Disconnect()
+ {
+ if(!m_Connected)
+ return E_FAIL;
+
+ // Terminate the protocol thread. On exit, it will fire the Disconnected event
+ TerminateProtocolThread();
+ return S_OK;
+ }
+
+ virtual STDMETHODIMP IMsTscAx::CreateVirtualChannels(BSTR newVal)
+ {
+ UINT strLength = SysStringLen(newVal);
+
+ if(strLength < 1 || strLength > 300)
+ return E_INVALIDARG;
+
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsTscAx::SendOnVirtualChannel(BSTR chanName, BSTR ChanData)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ /* IMsRdpClient */ // 6/10
+ virtual STDMETHODIMP IMsRdpClient::put_ColorDepth(long pcolorDepth)
+ {
+ switch(pcolorDepth)
+ {
+ case 8:
+ case 15:
+ case 16:
+ case 24:
+ case 32:
+ break;
+
+ default:
+ return E_INVALIDARG;
+ }
+
+ return SetProperty(m_ColorDepth, pcolorDepth);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_ColorDepth(long * pcolorDepth) const
+ {
+ return GetProperty(m_ColorDepth, pcolorDepth);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_AdvancedSettings2(MSTSCLib::IMsRdpClientAdvancedSettings ** ppAdvSettings) const
+ {
+ return GetAdvancedSettings(ppAdvSettings);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_SecuredSettings2(MSTSCLib::IMsRdpClientSecuredSettings ** ppSecuredSettings) const
+ {
+ return GetSecuredSettings(ppSecuredSettings);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_ExtendedDisconnectReason(MSTSCLib::ExtendedDisconnectReasonCode * pExtendedDisconnectReason) const
+ {
+ return GetProperty(m_ExtendedDisconnectReason, pExtendedDisconnectReason);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::put_FullScreen(VARIANT_BOOL pfFullScreen)
+ {
+ if(!m_Connected)
+ return E_FAIL;
+
+ if(pfFullScreen && !m_SecuredSettingsEnabled)
+ return E_FAIL;
+
+ // TODO
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::get_FullScreen(VARIANT_BOOL * pfFullScreen) const
+ {
+ return GetProperty(m_FullScreen, pfFullScreen);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::SetVirtualChannelOptions(BSTR chanName, long chanOptions)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::GetVirtualChannelOptions(BSTR chanName, long * pChanOptions)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsRdpClient::RequestClose(MSTSCLib::ControlCloseStatus * pCloseStatus)
+ {
+ if(pCloseStatus == NULL)
+ return E_POINTER;
+
+ if(!m_Connected)
+ {
+ *pCloseStatus = MSTSCLib::controlCloseCanProceed;
+ return S_OK;
+ }
+
+ *pCloseStatus = MSTSCLib::controlCloseWaitForEvents;
+
+ if(!PostMessage(m_controlWindow, RDPC_WM_REQUEST_CLOSE, 0, 0))
+ return HRESULT_FROM_WIN32(GetLastError());
+
+ return S_OK;
+ }
+
+ /* IMsRdpClient2 */
+ virtual STDMETHODIMP IMsRdpClient2::get_AdvancedSettings3(MSTSCLib::IMsRdpClientAdvancedSettings2 ** ppAdvSettings) const
+ {
+ return GetAdvancedSettings(ppAdvSettings);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient2::put_ConnectedStatusText(BSTR pConnectedStatusText)
+ {
+ return SetProperty(m_ConnectedStatusText, pConnectedStatusText);
+ }
+
+ virtual STDMETHODIMP IMsRdpClient2::get_ConnectedStatusText(BSTR * pConnectedStatusText) const
+ {
+ return GetProperty(m_ConnectedStatusText, pConnectedStatusText);
+ }
+
+ /* IMsRdpClient3 */
+ virtual STDMETHODIMP IMsRdpClient3::get_AdvancedSettings4(MSTSCLib::IMsRdpClientAdvancedSettings3 ** ppAdvSettings) const
+ {
+ return GetAdvancedSettings(ppAdvSettings);
+ }
+
+ /* IMsRdpClient4 */
+ virtual STDMETHODIMP IMsRdpClient4::get_AdvancedSettings5(MSTSCLib::IMsRdpClientAdvancedSettings4 ** ppAdvSettings5) const
+ {
+ return GetAdvancedSettings(ppAdvSettings5);
+ }
+
+ /* IMsTscNonScriptable */
+ virtual STDMETHODIMP IMsTscNonScriptable::put_ClearTextPassword(BSTR rhs)
+ {
+ return SetProperty(m_ClearTextPassword, rhs);
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::put_PortablePassword(BSTR pPortablePass)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::get_PortablePassword(BSTR * pPortablePass) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::put_PortableSalt(BSTR pPortableSalt)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::get_PortableSalt(BSTR * pPortableSalt) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::put_BinaryPassword(BSTR pBinaryPassword)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::get_BinaryPassword(BSTR * pBinaryPassword) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::put_BinarySalt(BSTR pSalt)
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::get_BinarySalt(BSTR * pSalt) const
+ {
+ return E_NOTIMPL;
+ }
+
+ virtual STDMETHODIMP IMsTscNonScriptable::ResetPassword()
+ {
+ return SetProperty(m_ClearTextPassword, NULL);
+ }
+
+ /* IMsRdpClientNonScriptable */ // 0/2
+ virtual STDMETHODIMP IMsRdpClientNonScriptable::NotifyRedirectDeviceChange(MSTSCLib::UINT_PTR wParam, MSTSCLib::LONG_PTR lParam)
+ {
+ return E_NOTIMPL; // TODO
+ }
+
+ virtual STDMETHODIMP IMsRdpClientNonScriptable::SendKeys(long numKeys, VARIANT_BOOL * pbArrayKeyUp, long * plKeyData)
+ {
+ // NOTE: the keys must be sent in a single, atomic sequence
+ // TODO: acquire the write lock
+ return E_NOTIMPL; // TODO
+ }
+
+ /* IMsRdpClientNonScriptable2 */
+ virtual STDMETHODIMP IMsRdpClientNonScriptable2::put_UIParentWindowHandle(HWND phwndUIParentWindowHandle)
+ {
+ return SetProperty(m_UIParentWindowHandle, phwndUIParentWindowHandle);
+ }
+
+ virtual STDMETHODIMP IMsRdpClientNonScriptable2::get_UIParentWindowHandle(HWND * phwndUIParentWindowHandle) const
+ {
+ return GetProperty(m_UIParentWindowHandle, phwndUIParentWindowHandle);
+ }
+};
+
+#pragma warning(pop)
+
+/* More glue to interface to the rdesktop code */
+extern "C"
+{
+
+/* Orders */
+/* support routines */
+void ui_begin_update(RDPCLIENT * This)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_BeginUpdate();
+}
+
+void ui_end_update(RDPCLIENT * This)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_EndUpdate();
+}
+
+void ui_set_clip(RDPCLIENT * This, int x, int y, int cx, int cy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_SetClip(x, y, cx, cy);
+}
+
+void ui_reset_clip(RDPCLIENT * This)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_ResetClip();
+}
+
+/* blits */
+void ui_destblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_DestBlt(opcode, x, y, cx, cy);
+}
+
+void ui_memblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy, HBITMAP src, int srcx, int srcy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_MemBlt(opcode, x, y, cx, cy, src, srcx, srcy);
+}
+
+void ui_patblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy, BRUSH * brush, int bgcolour, int fgcolour)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_PatBlt(opcode, x, y, cx, cy, brush, bgcolour, fgcolour);
+}
+
+void ui_screenblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy, int srcx, int srcy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_ScreenBlt(opcode, x, y, cx, cy, srcx, srcy);
+}
+
+void ui_triblt(RDPCLIENT * This, uint8 opcode, int x, int y, int cx, int cy, HBITMAP src, int srcx, int srcy, BRUSH * brush, int bgcolour, int fgcolour)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_TriBlt(opcode, x, y, cx, cy, src, srcx, srcy, brush, bgcolour, fgcolour);
+}
+
+void ui_paint_bitmap(RDPCLIENT * This, int x, int y, int cx, int cy, int width, int height, uint8 * data)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_PaintBitmap(x, y, cx, cy, width, height, data);
+}
+
+/* shapes */
+void ui_ellipse(RDPCLIENT * This, uint8 opcode, uint8 fillmode, int x, int y, int cx, int cy, BRUSH * brush, int bgcolour, int fgcolour)
+{
+ // TODO
+// RdpClient::InnerToOuter(This)->GetUI()->Display_Ellipse(opcode, fillmode, x, y, cx, cy, brush, bgcolour, fgcolour);
+}
+
+void ui_line(RDPCLIENT * This, uint8 opcode, int startx, int starty, int endx, int endy, PEN * pen)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_Line(opcode, startx, starty, endx, endy, pen);
+}
+
+void ui_polygon(RDPCLIENT * This, uint8 opcode, uint8 fillmode, POINT * point, int npoints, BRUSH * brush, int bgcolour, int fgcolour)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_Polygon(opcode, fillmode, point, npoints, brush, bgcolour, fgcolour);
+}
+
+void ui_polyline(RDPCLIENT * This, uint8 opcode, POINT * points, int npoints, PEN * pen)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_Polyline(opcode, points, npoints, pen);
+}
+
+void ui_rect(RDPCLIENT * This, int x, int y, int cx, int cy, int colour)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_Rect(x, y, cx, cy, colour);
+}
+
+/* text */
+void ui_draw_text
+(
+ RDPCLIENT * This,
+ uint8 font,
+ uint8 flags,
+ uint8 opcode,
+ int mixmode,
+ int x,
+ int y,
+ int clipx,
+ int clipy,
+ int clipcx,
+ int clipcy,
+ int boxx,
+ int boxy,
+ int boxcx,
+ int boxcy,
+ BRUSH * brush,
+ int bgcolour,
+ int fgcolour,
+ uint8 * text,
+ uint8 length
+)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_DrawText
+ (
+ font,
+ flags,
+ opcode,
+ mixmode,
+ x,
+ y,
+ clipx,
+ clipy,
+ clipcx,
+ clipcy,
+ boxx,
+ boxy,
+ boxcx,
+ boxcy,
+ brush,
+ bgcolour,
+ fgcolour,
+ text,
+ length
+ );
+}
+
+/* desktop save/restore */
+void ui_desktop_save(RDPCLIENT * This, uint32 offset, int x, int y, int cx, int cy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_SaveDesktop(offset, x, y, cx, cy);
+}
+
+void ui_desktop_restore(RDPCLIENT * This, uint32 offset, int x, int y, int cx, int cy)
+{
+ RdpClient::InnerToOuter(This)->GetUI()->Display_RestoreDesktop(offset, x, y, cx, cy);
+}
+
+/* Resources */
+/* bitmaps */
+HBITMAP ui_create_bitmap(RDPCLIENT * This, int width, int height, uint8 * data)
+{
+ return win32_create_dib(width, height, This->server_depth, data);
+}
+
+void ui_destroy_bitmap(RDPCLIENT *, HBITMAP bmp)
+{
+ DeleteObject(bmp);
+}
+
+/* palettes */
+HCOLOURMAP ui_create_colourmap(RDPCLIENT *, COLOURMAP * colours)
+{
+ return NULL;
+}
+
+void ui_set_colourmap(RDPCLIENT * This, HCOLOURMAP map)
+{
+ // TODO
+}
+
+/* cursors */
+HCURSOR ui_create_cursor(RDPCLIENT * This, unsigned int x, unsigned int y, int width, int height, uint8 * andmask, uint8 * xormask)
+{
+ uint8 * andbuf = NULL;
+ uint8 * xorbuf = NULL;
+
+ uint8 * andbits = win32_convert_scanlines(width, - height, 1, 2, 4, andmask, &andbuf);
+ uint8 * xorbits = win32_convert_scanlines(width, height, 24, 2, 4, xormask, &xorbuf);
+
+ HBITMAP hbmMask = CreateBitmap(width, height, 1, 1, andbits);
+ HBITMAP hbmColor = win32_create_dib(width, height, 24, xorbits);
+
+ ICONINFO iconinfo;
+ iconinfo.fIcon = FALSE;
+ iconinfo.xHotspot = x;
+ iconinfo.yHotspot = y;
+ iconinfo.hbmMask = hbmMask;
+ iconinfo.hbmColor = hbmColor;
+
+ HICON icon = CreateIconIndirect(&iconinfo);
+
+ if(icon == NULL)
+ error("CreateIconIndirect %dx%d failed\n", width, height);
+
+ if(andbuf)
+ delete[] andbuf;
+
+ if(xorbuf)
+ delete[] xorbuf;
+
+ DeleteObject(hbmMask);
+ DeleteObject(hbmColor);
+
+ return icon;
+}
+
+void ui_destroy_cursor(RDPCLIENT *, HCURSOR cursor)
+{
+ DestroyIcon(cursor);
+}
+
+/* glyphs */
+HGLYPH ui_create_glyph(RDPCLIENT * This, int width, int height, const uint8 * data)
+{
+ uint8 * databuf = NULL;
+ uint8 * databits = win32_convert_scanlines(width, height, 1, 1, 2, data, &databuf);
+
+ HBITMAP hbm = CreateBitmap(width, height, 1, 1, databits);
+
+ if(databuf)
+ delete[] databuf;
+
+ const uint8 * p = data;
+ int stride = alignup(alignup(width, 8) / 8, 1);
+
+#ifdef _DEBUG
+ printf("glyph %p\n", hbm);
+
+ for(int i = 0; i < height; ++ i, p += stride)
+ {
+ for(int j = 0; j < width; ++ j)
+ {
+ int B = p[j / 8];
+ int b = 8 - j % 8 - 1;
+
+ if(B & (1 << b))
+ fputs("##", stdout);
+ else
+ fputs("..", stdout);
+ }
+
+ fputc('\n', stdout);
+ }
+
+ fputc('\n', stdout);
+#endif
+
+ return hbm;
+}
+
+void ui_destroy_glyph(RDPCLIENT *, HGLYPH glyph)
+{
+ DeleteObject(glyph);
+}
+
+/* Input window */
+void ui_move_pointer(RDPCLIENT * This, int x, int y)
+{
+ // TODO
+}
+
+void ui_set_cursor(RDPCLIENT * This, HCURSOR cursor)
+{
+ // TODO
+}
+
+void ui_set_null_cursor(RDPCLIENT * This)
+{
+ // TODO
+}
+
+/* Miscellaneous */
+void ui_resize_window(RDPCLIENT * This)
+{
+}
+
+void ui_bell(RDPCLIENT *)
+{
+ MessageBeep(0);
+}
+
+int ui_select(RDPCLIENT * This, SOCKET rdp_socket)
+{
+ return SleepEx(0, TRUE) == WAIT_IO_COMPLETION;
+}
+
+/* Events */
+BOOL event_pubkey(RDPCLIENT * This, unsigned char * key, unsigned int key_size)
+{
+ if(!RdpClient::OnPublicKey(This, key, key_size))
+ return FALSE;
+ else
+ return TRUE;
+}
+
+void event_logon(RDPCLIENT * This)
+{
+ RdpClient::OnLogon(This);
+}
+
+BOOL event_redirect(RDPCLIENT * This, uint32 flags, uint32 server_len, wchar_t * server, uint32 cookie_len, char * cookie, uint32 username_len, wchar_t * username, uint32 domain_len, wchar_t * domain, uint32 password_len, wchar_t * password)
+{
+ if
+ (
+ !RdpClient::OnRedirect
+ (
+ This,
+ flags,
+ server_len,
+ server,
+ cookie_len,
+ cookie,
+ username_len,
+ username,
+ domain_len,
+ domain,
+ password_len,
+ password
+ )
+ )
+ return FALSE;
+ else
+ return TRUE;
+}
+
+}
+
+class ClassFactory: public IClassFactory
+{
+private:
+ LONG m_refCount;
+ CLSID m_classId;
+ unsigned m_libIndex;
+
+public:
+ ClassFactory(REFCLSID rclsid, unsigned libIndex):
+ m_refCount(1),
+ m_classId(rclsid)
+ {
+ lockServer();
+ }
+
+ ~ClassFactory()
+ {
+ unlockServer();
+ }
+
+ virtual STDMETHODIMP QueryInterface(REFIID riid, void ** ppvObject)
+ {
+ if(riid == IID_IUnknown || riid == IID_IClassFactory)
+ {
+ *ppvObject = this;
+ return S_OK;
+ }
+ else
+ {
+ *ppvObject = NULL;
+ return E_NOINTERFACE;
+ }
+ }
+
+ virtual STDMETHODIMP_(ULONG) AddRef()
+ {
+ return InterlockedIncrement(&m_refCount);
+ }
+
+ virtual STDMETHODIMP_(ULONG) Release()
+ {
+ LONG n = InterlockedDecrement(&m_refCount);
+
+ if(n == 0)
+ delete this;
+
+ return n;
+ }
+
+ virtual STDMETHODIMP CreateInstance(IUnknown * pUnkOuter, REFIID riid, void ** ppvObject)
+ {
+ if(pUnkOuter && riid != IID_IUnknown)
+ return CLASS_E_NOAGGREGATION;
+
+ return RdpClient::CreateInstance(m_classId, m_libIndex, pUnkOuter, riid, ppvObject);
+ }
+
+ virtual STDMETHODIMP LockServer(BOOL fLock)
+ {
+ if(fLock)
+ lockServer();
+ else
+ unlockServer();
+
+ return S_OK;
+ }
+};
+
+extern "C"
+{
+
+STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID * ppv)
+{
+ unsigned libindex;
+
+ if
+ (
+ rclsid == MSTSCLib::CLSID_MsTscAx ||
+ rclsid == MSTSCLib::CLSID_MsRdpClient ||
+ rclsid == MSTSCLib::CLSID_MsRdpClient2 ||
+ rclsid == MSTSCLib::CLSID_MsRdpClient3 ||
+ rclsid == MSTSCLib::CLSID_MsRdpClient4
+ )
+ libindex = 1;
+ else if
+ (
+ rclsid == MSTSCLib_Redist::CLSID_MsTscAx ||
+ rclsid == MSTSCLib_Redist::CLSID_MsRdpClient ||
+ rclsid == MSTSCLib_Redist::CLSID_MsRdpClient2 ||
+ rclsid == MSTSCLib_Redist::CLSID_MsRdpClient3 // ||
+ // rclsid != MSTSCLib::CLSID_MsRdpClient4
+ )
+ libindex = 2;
+ else
+ return CLASS_E_CLASSNOTAVAILABLE;
+
+ ClassFactory * p = new ClassFactory(rclsid, libindex);
+
+ if(p == NULL)
+ return E_OUTOFMEMORY;
+
+ HRESULT hr = p->QueryInterface(riid, ppv);
+
+ p->Release();
+
+ if(FAILED(hr))
+ return hr;
+
+ return S_OK;
+}
+
+STDAPI DllCanUnloadNow(void)
+{
+ return canUnloadServer() ? S_OK : S_FALSE;
+}
+
+STDAPI_(ULONG) DllGetTscCtlVer(void)
+{
+ // BUGBUG: don't hardcode this
+ return 0x05020ECE; // 5.2.3790
+}
+
+DWORD WINAPI DllMain(HINSTANCE hInstance, DWORD fdwReason, LPVOID lpvReserved)
+{
+ assert(hInstance == GetCurrentModule());
+
+ switch(fdwReason)
+ {
+ case DLL_PROCESS_ATTACH:
+ {
+ DisableThreadLibraryCalls(hInstance);
+
+ if(!RdpClient::Startup())
+ return FALSE;
+ }
+
+ break;
+
+ case DLL_PROCESS_DETACH:
+ {
+ // Process is terminating, no need to clean up
+ if(lpvReserved)
+ break;
+
+ RdpClient::Shutdown();
+ }
+
+ break;
+ }
+
+ return TRUE;
+}
+
+}
+
+// EOF
projects / reactos.git / blobdiff