}
}
-void android_begin_paint(rdpContext* context)
+BOOL android_begin_paint(rdpContext* context)
{
rdpGdi* gdi = context->gdi;
gdi->primary->hdc->hwnd->invalid->null = 1;
gdi->primary->hdc->hwnd->ninvalid = 0;
+ return TRUE;
}
-void android_end_paint(rdpContext* context)
+BOOL android_end_paint(rdpContext* context)
{
int i;
int ninvalid;
if (ninvalid == 0)
{
DEBUG_ANDROID("ui_update: ninvalid=%d", ninvalid);
- return;
+ return TRUE;
}
cinvalid = ctx->rdpCtx.gdi->primary->hdc->hwnd->cinvalid;
freerdp_callback("OnGraphicsUpdate", "(IIIII)V", context->instance,
x1, y1, x2 - x1, y2 - y1);
+ return TRUE;
}
-void android_desktop_resize(rdpContext* context)
+BOOL android_desktop_resize(rdpContext* context)
{
DEBUG_ANDROID("ui_desktop_resize");
freerdp_callback("OnGraphicsResize", "(IIII)V",
context->instance, context->settings->DesktopWidth,
context->settings->DesktopHeight, context->settings->ColorDepth);
+ return TRUE;
}
BOOL android_pre_connect(freerdp* instance)
#define TAG CLIENT_TAG("mac")
-void mf_Pointer_New(rdpContext* context, rdpPointer* pointer);
+BOOL mf_Pointer_New(rdpContext* context, rdpPointer* pointer);
void mf_Pointer_Free(rdpContext* context, rdpPointer* pointer);
-void mf_Pointer_Set(rdpContext* context, rdpPointer* pointer);
-void mf_Pointer_SetNull(rdpContext* context);
-void mf_Pointer_SetDefault(rdpContext* context);
+BOOL mf_Pointer_Set(rdpContext* context, rdpPointer* pointer);
+BOOL mf_Pointer_SetNull(rdpContext* context);
+BOOL mf_Pointer_SetDefault(rdpContext* context);
-void mac_begin_paint(rdpContext* context);
-void mac_end_paint(rdpContext* context);
-void mac_desktop_resize(rdpContext* context);
+BOOL mac_begin_paint(rdpContext* context);
+BOOL mac_end_paint(rdpContext* context);
+BOOL mac_desktop_resize(rdpContext* context);
static void update_activity_cb(freerdp* instance);
static void input_activity_cb(freerdp* instance);
return ok;
}
-void mf_Pointer_New(rdpContext* context, rdpPointer* pointer)
+BOOL mf_Pointer_New(rdpContext* context, rdpPointer* pointer)
{
NSRect rect;
NSImage* image;
rect.origin.y = pointer->yPos;
cursor_data = (BYTE*) malloc(rect.size.width * rect.size.height * 4);
+ if (!cursor_data)
+ return FALSE;
mrdpCursor->cursor_data = cursor_data;
freerdp_image_copy_from_pointer_data(cursor_data, PIXEL_FORMAT_ARGB32,
/* save cursor for later use in mf_Pointer_Set() */
ma = view->cursors;
[ma addObject:mrdpCursor];
+ return TRUE;
}
void mf_Pointer_Free(rdpContext* context, rdpPointer* pointer)
}
}
-void mf_Pointer_Set(rdpContext* context, rdpPointer* pointer)
+BOOL mf_Pointer_Set(rdpContext* context, rdpPointer* pointer)
{
mfContext* mfc = (mfContext*) context;
MRDPView* view = (MRDPView*) mfc->view;
if (cursor->pointer == pointer)
{
[view setCursor:cursor->nsCursor];
- return;
+ return TRUE;
}
}
NSLog(@"Cursor not found");
+ return TRUE;
}
-void mf_Pointer_SetNull(rdpContext* context)
+BOOL mf_Pointer_SetNull(rdpContext* context)
{
-
+ return TRUE;
}
-void mf_Pointer_SetDefault(rdpContext* context)
+BOOL mf_Pointer_SetDefault(rdpContext* context)
{
mfContext* mfc = (mfContext*) context;
MRDPView* view = (MRDPView*) mfc->view;
[view setCursor:[NSCursor arrowCursor]];
+ return TRUE;
}
CGContextRef mac_create_bitmap_context(rdpContext* context)
return bitmap_context;
}
-void mac_begin_paint(rdpContext* context)
+BOOL mac_begin_paint(rdpContext* context)
{
rdpGdi* gdi = context->gdi;
if (!gdi)
- return;
+ return FALSE;
gdi->primary->hdc->hwnd->invalid->null = 1;
+ return TRUE;
}
-void mac_end_paint(rdpContext* context)
+BOOL mac_end_paint(rdpContext* context)
{
rdpGdi* gdi;
HGDI_RGN invalid;
gdi = context->gdi;
if (!gdi)
- return;
+ return FALSE;
ww = mfc->client_width;
wh = mfc->client_height;
dh = mfc->context.settings->DesktopHeight;
if ((!context) || (!context->gdi))
- return;
+ return FALSE;
if (context->gdi->primary->hdc->hwnd->invalid->null)
- return;
+ return TRUE;
invalid = gdi->primary->hdc->hwnd->invalid;
[view setNeedsDisplayInRect:newDrawRect];
gdi->primary->hdc->hwnd->ninvalid = 0;
+ return TRUE;
}
-void mac_desktop_resize(rdpContext* context)
+BOOL mac_desktop_resize(rdpContext* context)
{
mfContext* mfc = (mfContext*) context;
MRDPView* view = (MRDPView*) mfc->view;
gdi_resize(context->gdi, mfc->width, mfc->height);
view->bitmap_context = mac_create_bitmap_context(context);
+ if (!view->bitmap_context)
+ return FALSE;
+ return TRUE;
}
static void update_activity_cb(freerdp* instance)
* Client Interface
*/
-void mfreerdp_client_global_init()
+BOOL mfreerdp_client_global_init()
{
freerdp_handle_signals();
+ return TRUE;
}
void mfreerdp_client_global_uninit()
}
}
-static void tf_begin_paint(rdpContext* context)
+static BOOL tf_begin_paint(rdpContext* context)
{
rdpGdi* gdi = context->gdi;
gdi->primary->hdc->hwnd->invalid->null = 1;
+ return TRUE;
}
-static void tf_end_paint(rdpContext* context)
+static BOOL tf_end_paint(rdpContext* context)
{
rdpGdi* gdi = context->gdi;
if (gdi->primary->hdc->hwnd->invalid->null)
- return;
+ return TRUE;
+ return TRUE;
}
static BOOL tf_pre_connect(freerdp* instance)
return display;
}
-void wlf_RefreshDisplay(wlfDisplay* display)
+BOOL wlf_RefreshDisplay(wlfDisplay* display)
{
- wl_display_dispatch(display->display);
+ if (wl_display_dispatch(display->display) == -1)
+ return FALSE;
+ return TRUE;
}
void wlf_DestroyDisplay(wlfContext* wlfc, wlfDisplay* display)
};
wlfDisplay* wlf_CreateDisplay(void);
-void wlf_RefreshDisplay(wlfDisplay* display);
+BOOL wlf_RefreshDisplay(wlfDisplay* display);
void wlf_DestroyDisplay(wlfContext* wlfc, wlfDisplay* display);
#endif /* __WLF_DISPLAY_H */
}
-void wl_begin_paint(rdpContext* context)
+BOOL wl_begin_paint(rdpContext* context)
{
rdpGdi* gdi;
gdi = context->gdi;
gdi->primary->hdc->hwnd->invalid->null = 1;
+ return TRUE;
}
-void wl_end_paint(rdpContext* context)
+BOOL wl_end_paint(rdpContext* context)
{
rdpGdi* gdi;
wlfDisplay* display;
gdi = context->gdi;
if (gdi->primary->hdc->hwnd->invalid->null)
- return;
+ return TRUE;
x = gdi->primary->hdc->hwnd->invalid->x;
y = gdi->primary->hdc->hwnd->invalid->y;
gdi->primary_buffer + ((i+y)*(gdi->width*4)) + x*4,
w*4);
- wlf_RefreshDisplay(display);
+ return wlf_RefreshDisplay(display);
}
BOOL wl_pre_connect(freerdp* instance)
return 0;
}
-void wf_sw_begin_paint(wfContext* wfc)
+BOOL wf_sw_begin_paint(wfContext* wfc)
{
rdpGdi* gdi = ((rdpContext*) wfc)->gdi;
gdi->primary->hdc->hwnd->invalid->null = 1;
gdi->primary->hdc->hwnd->ninvalid = 0;
+ return TRUE;
}
-void wf_sw_end_paint(wfContext* wfc)
+BOOL wf_sw_end_paint(wfContext* wfc)
{
int i;
rdpGdi* gdi;
cinvalid = gdi->primary->hdc->hwnd->cinvalid;
if (ninvalid < 1)
- return;
+ return TRUE;
region16_init(&invalidRegion);
}
region16_uninit(&invalidRegion);
+ return TRUE;
}
-void wf_sw_desktop_resize(wfContext* wfc)
+BOOL wf_sw_desktop_resize(wfContext* wfc)
{
rdpGdi* gdi;
rdpContext* context;
gdi_init(instance, CLRCONV_ALPHA | CLRBUF_32BPP, wfc->primary->pdata);
gdi = instance->context->gdi;
wfc->hdc = gdi->primary->hdc;
+ return TRUE;
}
-void wf_hw_begin_paint(wfContext* wfc)
+BOOL wf_hw_begin_paint(wfContext* wfc)
{
wfc->hdc->hwnd->invalid->null = 1;
wfc->hdc->hwnd->ninvalid = 0;
+ return TRUE;
}
-void wf_hw_end_paint(wfContext* wfc)
+BOOL wf_hw_end_paint(wfContext* wfc)
{
-
+ return TRUE;
}
-void wf_hw_desktop_resize(wfContext* wfc)
+BOOL wf_hw_desktop_resize(wfContext* wfc)
{
BOOL same;
RECT rect;
GetWindowRect(wfc->hwnd, &rect);
InvalidateRect(wfc->hwnd, &rect, TRUE);
}
+ return TRUE;
}
BOOL wf_pre_connect(freerdp* instance)
wf_update_canvas_diff(wfc);
}
-void wfreerdp_client_global_init(void)
+BOOL wfreerdp_client_global_init(void)
{
WSADATA wsaData;
#endif
freerdp_register_addin_provider(freerdp_channels_load_static_addin_entry, 0);
+ return TRUE;
}
void wfreerdp_client_global_uninit(void)
}
}
-void wf_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
+BOOL wf_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
{
HDC hdc;
int status;
wfContext* wfc = (wfContext*) context;
hdc = CreateCompatibleDC(GetDC(NULL));
+ if (!hdc)
+ return FALSE;
for (index = 0; index < bitmapUpdate->number; index++)
{
wfc->bitmap_buffer = (BYTE*) _aligned_realloc(wfc->bitmap_buffer, wfc->bitmap_size, 16);
if (!wfc->bitmap_buffer)
- return;
+ return FALSE;
}
if (compressed)
if (status < 0)
{
WLog_ERR(TAG, "bitmap decompression failure");
- return;
+ return FALSE;
}
pSrcData = wfc->bitmap_buffer;
}
ReleaseDC(NULL, hdc);
+ return TRUE;
}
void wf_gdi_palette_update(wfContext* wfc, PALETTE_UPDATE* palette)
void wf_resize_window(wfContext* wfc);
void wf_toggle_fullscreen(wfContext* wfc);
-void wf_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate);
+BOOL wf_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate);
void wf_gdi_register_update_callbacks(rdpUpdate* update);
void wf_update_canvas_diff(wfContext* wfc);
WS_OVERLAPPED | WS_VSCROLL | WS_HSCROLL | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX)
#define RAIL_DISABLED_EXTENDED_WINDOW_STYLES (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE | WS_EX_WINDOWEDGE)
-static void wf_rail_window_common(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* windowState)
+static BOOL wf_rail_window_common(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* windowState)
{
wfRailWindow* railWindow = NULL;
wfContext* wfc = (wfContext*) context;
railWindow = (wfRailWindow*) calloc(1, sizeof(wfRailWindow));
if (!railWindow)
- return;
+ return FALSE;
railWindow->wfc = wfc;
UpdateWindow(railWindow->hWnd);
- return;
+ return TRUE;
}
else
{
}
if (!railWindow)
- return;
+ return TRUE;
if ((fieldFlags & WINDOW_ORDER_FIELD_WND_OFFSET) ||
(fieldFlags & WINDOW_ORDER_FIELD_WND_SIZE))
}
UpdateWindow(railWindow->hWnd);
+ return TRUE;
}
-static void wf_rail_window_delete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL wf_rail_window_delete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
wfRailWindow* railWindow = NULL;
wfContext* wfc = (wfContext*) context;
(void*) (UINT_PTR) orderInfo->windowId);
if (!railWindow)
- return;
+ return TRUE;
HashTable_Remove(wfc->railWindows, (void*) (UINT_PTR) orderInfo->windowId);
DestroyWindow(railWindow->hWnd);
free(railWindow);
+ return TRUE;
}
-static void wf_rail_window_icon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* windowIcon)
+static BOOL wf_rail_window_icon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* windowIcon)
{
HDC hDC;
int bpp;
(void*) (UINT_PTR) orderInfo->windowId);
if (!railWindow)
- return;
+ return TRUE;
bigIcon = (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_ICON_BIG) ? TRUE : FALSE;
{
/* icon should be cached */
}
+ return TRUE;
}
-static void wf_rail_window_cached_icon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
+static BOOL wf_rail_window_cached_icon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
{
WLog_DBG(TAG, "RailWindowCachedIcon");
+ return TRUE;
}
static void wf_rail_notify_icon_common(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
}
}
-static void wf_rail_notify_icon_create(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
+static BOOL wf_rail_notify_icon_create(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
{
wfContext* wfc = (wfContext*) context;
RailClientContext* rail = wfc->rail;
WLog_DBG(TAG, "RailNotifyIconCreate");
wf_rail_notify_icon_common(context, orderInfo, notifyIconState);
+ return TRUE;
}
-static void wf_rail_notify_icon_update(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
+static BOOL wf_rail_notify_icon_update(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
{
wfContext* wfc = (wfContext*) context;
RailClientContext* rail = wfc->rail;
WLog_DBG(TAG, "RailNotifyIconUpdate");
wf_rail_notify_icon_common(context, orderInfo, notifyIconState);
+ return TRUE;
}
-static void wf_rail_notify_icon_delete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL wf_rail_notify_icon_delete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
wfContext* wfc = (wfContext*) context;
RailClientContext* rail = wfc->rail;
WLog_DBG(TAG, "RailNotifyIconDelete");
+ return TRUE;
}
-static void wf_rail_monitored_desktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, MONITORED_DESKTOP_ORDER* monitoredDesktop)
+static BOOL wf_rail_monitored_desktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, MONITORED_DESKTOP_ORDER* monitoredDesktop)
{
wfContext* wfc = (wfContext*) context;
RailClientContext* rail = wfc->rail;
WLog_DBG(TAG, "RailMonitorDesktop");
+ return TRUE;
}
-static void wf_rail_non_monitored_desktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL wf_rail_non_monitored_desktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
wfContext* wfc = (wfContext*) context;
RailClientContext* rail = wfc->rail;
WLog_DBG(TAG, "RailNonMonitorDesktop");
+ return TRUE;
}
void wf_rail_register_update_callbacks(rdpUpdate* update)
}
}
-void xf_sw_begin_paint(rdpContext* context)
+BOOL xf_sw_begin_paint(rdpContext* context)
{
rdpGdi* gdi = context->gdi;
gdi->primary->hdc->hwnd->invalid->null = 1;
gdi->primary->hdc->hwnd->ninvalid = 0;
+ return TRUE;
}
-void xf_sw_end_paint(rdpContext* context)
+BOOL xf_sw_end_paint(rdpContext* context)
{
int i;
INT32 x, y;
if (!xfc->complex_regions)
{
if (gdi->primary->hdc->hwnd->invalid->null)
- return;
+ return TRUE;
xf_lock_x11(xfc, FALSE);
else
{
if (gdi->primary->hdc->hwnd->ninvalid < 1)
- return;
+ return TRUE;
xf_lock_x11(xfc, FALSE);
else
{
if (gdi->primary->hdc->hwnd->invalid->null)
- return;
+ return TRUE;
xf_lock_x11(xfc, FALSE);
xf_unlock_x11(xfc, FALSE);
}
+ return TRUE;
}
-void xf_sw_desktop_resize(rdpContext* context)
+BOOL xf_sw_desktop_resize(rdpContext* context)
{
rdpGdi* gdi = context->gdi;
xfContext* xfc = (xfContext*) context;
xf_desktop_resize(context);
xf_unlock_x11(xfc, TRUE);
+ return TRUE;
}
-void xf_hw_begin_paint(rdpContext* context)
+BOOL xf_hw_begin_paint(rdpContext* context)
{
xfContext* xfc = (xfContext*) context;
xfc->hdc->hwnd->invalid->null = 1;
xfc->hdc->hwnd->ninvalid = 0;
+ return TRUE;
}
-void xf_hw_end_paint(rdpContext* context)
+BOOL xf_hw_end_paint(rdpContext* context)
{
INT32 x, y;
UINT32 w, h;
if (!xfc->complex_regions)
{
if (xfc->hdc->hwnd->invalid->null)
- return;
+ return TRUE;
x = xfc->hdc->hwnd->invalid->x;
y = xfc->hdc->hwnd->invalid->y;
HGDI_RGN cinvalid;
if (xfc->hdc->hwnd->ninvalid < 1)
- return;
+ return TRUE;
ninvalid = xfc->hdc->hwnd->ninvalid;
cinvalid = xfc->hdc->hwnd->cinvalid;
else
{
if (xfc->hdc->hwnd->invalid->null)
- return;
+ return TRUE;
x = xfc->hdc->hwnd->invalid->x;
y = xfc->hdc->hwnd->invalid->y;
xf_unlock_x11(xfc, FALSE);
}
+ return TRUE;
}
-void xf_hw_desktop_resize(rdpContext* context)
+BOOL xf_hw_desktop_resize(rdpContext* context)
{
xfContext* xfc = (xfContext*) context;
rdpSettings* settings = xfc->settings;
xf_desktop_resize(context);
xf_unlock_x11(xfc, TRUE);
+ return TRUE;
}
BOOL xf_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount)
return xf_error_handler(d, ev);
}
-static void xf_play_sound(rdpContext* context, PLAY_SOUND_UPDATE* play_sound)
+static BOOL xf_play_sound(rdpContext* context, PLAY_SOUND_UPDATE* play_sound)
{
xfContext* xfc = (xfContext*) context;
XkbBell(xfc->display, None, 100, 0);
+ return TRUE;
}
void xf_check_extensions(xfContext* context)
* Client Interface
*/
-static void xfreerdp_client_global_init()
+static BOOL xfreerdp_client_global_init()
{
setlocale(LC_ALL, "");
- freerdp_handle_signals();
+ if (freerdp_handle_signals() != 0)
+ return FALSE;
+ return TRUE;
}
static void xfreerdp_client_global_uninit()
return bitmap;
}
-void xf_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
+BOOL xf_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
{
int status;
int nXDst;
xfc->bitmap_buffer = (BYTE*) _aligned_realloc(xfc->bitmap_buffer, xfc->bitmap_size, 16);
if (!xfc->bitmap_buffer)
- return;
+ return FALSE;
}
if (compressed)
if (status < 0)
{
WLog_ERR(TAG, "bitmap decompression failure");
- return;
+ return FALSE;
}
pSrcData = xfc->bitmap_buffer;
xf_unlock_x11(xfc, FALSE);
}
+ return TRUE;
}
-void xf_gdi_palette_update(rdpContext* context, PALETTE_UPDATE* palette)
+static BOOL xf_gdi_palette_update(rdpContext* context, PALETTE_UPDATE* palette)
{
int index;
PALETTE_ENTRY* pe;
}
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_set_bounds(rdpContext* context, rdpBounds* bounds)
+static BOOL xf_gdi_set_bounds(rdpContext* context, rdpBounds* bounds)
{
XRectangle clip;
xfContext* xfc = (xfContext*) context;
}
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_dstblt(rdpContext* context, DSTBLT_ORDER* dstblt)
+static BOOL xf_gdi_dstblt(rdpContext* context, DSTBLT_ORDER* dstblt)
{
xfContext* xfc = (xfContext*) context;
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
+static BOOL xf_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
{
Pixmap pattern;
rdpBrush* brush;
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_scrblt(rdpContext* context, SCRBLT_ORDER* scrblt)
+static BOOL xf_gdi_scrblt(rdpContext* context, SCRBLT_ORDER* scrblt)
{
xfContext* xfc = (xfContext*) context;
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect)
+BOOL xf_gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect)
{
UINT32 color;
xfContext* xfc = (xfContext*) context;
}
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_multi_opaque_rect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
+BOOL xf_gdi_multi_opaque_rect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
{
int i;
UINT32 color;
}
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
void xf_gdi_draw_nine_grid(rdpContext* context, DRAW_NINE_GRID_ORDER* draw_nine_grid)
WLog_ERR(TAG, "DrawNineGrid");
}
-void xf_gdi_line_to(rdpContext* context, LINE_TO_ORDER* line_to)
+BOOL xf_gdi_line_to(rdpContext* context, LINE_TO_ORDER* line_to)
{
UINT32 color;
xfContext* xfc = (xfContext*) context;
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
static void xf_gdi_invalidate_poly_region(xfContext* xfc, XPoint* points, int npoints, BOOL autoclose)
}
}
-void xf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
+BOOL xf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
{
int i;
int npoints;
npoints = polyline->numDeltaEntries + 1;
points = malloc(sizeof(XPoint) * npoints);
+ if (!points)
+ {
+ xf_unlock_x11(xfc, FALSE);
+ return FALSE;
+ }
points[0].x = polyline->xStart;
points[0].y = polyline->yStart;
free(points);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
+BOOL xf_gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
{
xfBitmap* bitmap;
xfContext* xfc = (xfContext*) context;
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
+BOOL xf_gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
{
rdpBrush* brush;
xfBitmap* bitmap;
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc)
+BOOL xf_gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc)
{
int i, npoints;
XPoint* points;
npoints = polygon_sc->numPoints + 1;
points = malloc(sizeof(XPoint) * npoints);
+ if (!points)
+ {
+ xf_unlock_x11(xfc, FALSE);
+ return FALSE;
+ }
points[0].x = polygon_sc->xStart;
points[0].y = polygon_sc->yStart;
free(points);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
+BOOL xf_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
{
int i, npoints;
XPoint* points;
npoints = polygon_cb->numPoints + 1;
points = malloc(sizeof(XPoint) * npoints);
+ if (!points)
+ {
+ xf_unlock_x11(xfc, FALSE);
+ return FALSE;
+ }
points[0].x = polygon_cb->xStart;
points[0].y = polygon_cb->yStart;
free(points);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_gdi_ellipse_sc(rdpContext* context, ELLIPSE_SC_ORDER* ellipse_sc)
+BOOL xf_gdi_ellipse_sc(rdpContext* context, ELLIPSE_SC_ORDER* ellipse_sc)
{
- WLog_ERR(TAG, "EllipseSC");
+ WLog_ERR(TAG, "Not implemented: EllipseSC");
+ return TRUE;
}
-void xf_gdi_ellipse_cb(rdpContext* context, ELLIPSE_CB_ORDER* ellipse_cb)
+BOOL xf_gdi_ellipse_cb(rdpContext* context, ELLIPSE_CB_ORDER* ellipse_cb)
{
- WLog_ERR(TAG, "EllipseCB");
+ WLog_ERR(TAG, "Not implemented: EllipseCB");
+ return TRUE;
}
-void xf_gdi_frame_marker(rdpContext* context, FRAME_MARKER_ORDER* frameMarker)
+BOOL xf_gdi_frame_marker(rdpContext* context, FRAME_MARKER_ORDER* frameMarker)
{
+ return TRUE;
}
-void xf_gdi_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surface_frame_marker)
+BOOL xf_gdi_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surface_frame_marker)
{
rdpSettings* settings;
xfContext* xfc = (xfContext*) context;
}
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
static void xf_gdi_surface_update_frame(xfContext* xfc, UINT16 tx, UINT16 ty, UINT16 width, UINT16 height)
}
}
-void xf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* cmd)
+BOOL xf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* cmd)
{
int i, tx, ty;
XImage* image;
xfc->bitmap_buffer = (BYTE*) _aligned_realloc(xfc->bitmap_buffer, xfc->bitmap_size, 16);
if (!xfc->bitmap_buffer)
- return;
+ return FALSE;
}
/* Draw the tiles to primary surface, each is 64x64. */
xfc->bitmap_buffer = (BYTE*) _aligned_realloc(xfc->bitmap_buffer, xfc->bitmap_size, 16);
if (!xfc->bitmap_buffer)
- return;
+ return FALSE;
}
pSrcData = xfc->codecs->nsc->BitmapData;
xfc->bitmap_buffer = (BYTE*) _aligned_realloc(xfc->bitmap_buffer, xfc->bitmap_size, 16);
if (!xfc->bitmap_buffer)
- return;
+ return FALSE;
}
pSrcData = cmd->bitmapData;
}
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
void xf_gdi_register_update_callbacks(rdpUpdate* update)
#include "xfreerdp.h"
void xf_gdi_register_update_callbacks(rdpUpdate* update);
-void xf_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate);
+BOOL xf_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate);
UINT32 xf_convert_rdp_order_color(xfContext* xfc, UINT32 color);
#endif /* __XF_GDI_H */
/* Bitmap Class */
-void xf_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
+BOOL xf_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
{
int depth;
BYTE* data;
data = _aligned_malloc(bitmap->width * bitmap->height * 4, 16);
if (!data)
- return;
+ return FALSE;
SrcFormat = gdi_get_pixel_format(bitmap->bpp, TRUE);
((xfBitmap*) bitmap)->pixmap = pixmap;
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
void xf_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
xf_unlock_x11(xfc, FALSE);
}
-void xf_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
+BOOL xf_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
{
XImage* image;
int width, height;
gdi_InvalidateRegion(xfc->hdc, bitmap->left, bitmap->top, width, height);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
+BOOL xf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
BYTE* data, int width, int height, int bpp, int length,
BOOL compressed, int codecId)
{
size = width * height * 4;
bitmap->data = (BYTE*) _aligned_malloc(size, 16);
+ if (!bitmap->data)
+ return FALSE;
pSrcData = data;
SrcSize = (UINT32) length;
if (status < 0)
{
WLog_ERR(TAG, "Bitmap Decompression Failed");
- return;
+ return FALSE;
}
}
else
bitmap->compressed = FALSE;
bitmap->length = size;
bitmap->bpp = (xfc->depth >= 24) ? 32 : xfc->depth;
+ return TRUE;
}
-void xf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
+BOOL xf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
{
xfContext* xfc = (xfContext*) context;
xfc->drawing = ((xfBitmap*) bitmap)->pixmap;
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
/* Pointer Class */
-void xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
+BOOL xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
{
#ifdef WITH_XCURSOR
XcursorImage ci;
ci.pixels = (XcursorPixel*) calloc(1, ci.width * ci.height * 4);
if (!ci.pixels)
- return;
+ return FALSE;
if ((pointer->andMaskData != 0) && (pointer->xorMaskData != 0))
{
xf_unlock_x11(xfc, FALSE);
#endif
+ return TRUE;
}
void xf_Pointer_Free(rdpContext* context, rdpPointer* pointer)
#endif
}
-void xf_Pointer_Set(rdpContext* context, rdpPointer* pointer)
+BOOL xf_Pointer_Set(rdpContext* context, rdpPointer* pointer)
{
#ifdef WITH_XCURSOR
xfContext* xfc = (xfContext*) context;
xf_unlock_x11(xfc, FALSE);
#endif
+ return TRUE;
}
-void xf_Pointer_SetNull(rdpContext* context)
+BOOL xf_Pointer_SetNull(rdpContext* context)
{
#ifdef WITH_XCURSOR
xfContext* xfc = (xfContext*) context;
xf_unlock_x11(xfc, FALSE);
#endif
+ return TRUE;
}
-void xf_Pointer_SetDefault(rdpContext* context)
+BOOL xf_Pointer_SetDefault(rdpContext* context)
{
#ifdef WITH_XCURSOR
xfContext* xfc = (xfContext*) context;
xf_unlock_x11(xfc, FALSE);
#endif
+ return TRUE;
}
-void xf_Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y)
+BOOL xf_Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y)
{
xfContext* xfc = (xfContext*) context;
XWindowAttributes current;
XSetWindowAttributes tmp;
+ BOOL ret = FALSE;
if (!xfc->focused || !xfc->window)
- return;
+ return TRUE;
xf_lock_x11(xfc, FALSE);
tmp.event_mask = current.your_event_mask;
XChangeWindowAttributes(xfc->display, xfc->window->handle, CWEventMask, &tmp);
+ ret = TRUE;
out:
- xf_unlock_x11(xfc, FALSE);
- return;
+ xf_unlock_x11(xfc, FALSE);
+ return ret;
}
/* Glyph Class */
-void xf_Glyph_New(rdpContext* context, rdpGlyph* glyph)
+BOOL xf_Glyph_New(rdpContext* context, rdpGlyph* glyph)
{
int scanline;
XImage* image;
XFree(image);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
void xf_Glyph_Free(rdpContext* context, rdpGlyph* glyph)
xf_unlock_x11(xfc, FALSE);
}
-void xf_Glyph_Draw(rdpContext* context, rdpGlyph* glyph, int x, int y)
+BOOL xf_Glyph_Draw(rdpContext* context, rdpGlyph* glyph, int x, int y)
{
xfGlyph* xf_glyph;
xfContext* xfc = (xfContext*) context;
XSetStipple(xfc->display, xfc->gc, xfc->bitmap_mono);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
+BOOL xf_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
{
xfContext* xfc = (xfContext*) context;
XSetFillStyle(xfc->display, xfc->gc, fOpRedundant ? FillOpaqueStippled : FillStippled);
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
-void xf_Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor)
+BOOL xf_Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor)
{
xfContext* xfc = (xfContext*) context;
}
xf_unlock_x11(xfc, FALSE);
+ return TRUE;
}
/* Graphics Module */
}
#endif /* WITH_XRENDER defined */
#endif /* pinch/zoom/pan simulation */
-
- return FALSE;
+ return TRUE;
}
-void xf_keyboard_set_indicators(rdpContext* context, UINT16 led_flags)
+BOOL xf_keyboard_set_indicators(rdpContext* context, UINT16 led_flags)
{
xfContext* xfc = (xfContext*) context;
xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_NUM_LOCK, XK_Num_Lock);
xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_CAPS_LOCK, XK_Caps_Lock);
xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_KANA_LOCK, XK_Kana_Lock);
+ return TRUE;
}
UINT32 xf_keyboard_get_toggle_keys_state(xfContext* xfc);
void xf_keyboard_focus_in(xfContext* xfc);
BOOL xf_keyboard_handle_special_keys(xfContext* xfc, KeySym keysym);
-void xf_keyboard_set_indicators(rdpContext* context, UINT16 led_flags);
+BOOL xf_keyboard_set_indicators(rdpContext* context, UINT16 led_flags);
#endif /* __XF_KEYBOARD_H */
/* RemoteApp Core Protocol Extension */
-static void xf_rail_window_common(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* windowState)
+static BOOL xf_rail_window_common(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* windowState)
{
xfAppWindow* appWindow = NULL;
xfContext* xfc = (xfContext*) context;
appWindow = (xfAppWindow*) calloc(1, sizeof(xfAppWindow));
if (!appWindow)
- return;
+ return FALSE;
appWindow->xfc = xfc;
xf_AppWindowInit(xfc, appWindow);
- return;
+ return TRUE;
}
else
{
}
if (!appWindow)
- return;
+ return FALSE;
/* Update Parameters */
appWindow->windowRects = (RECTANGLE_16*) calloc(appWindow->numWindowRects, sizeof(RECTANGLE_16));
if (!appWindow->windowRects)
- return;
+ return FALSE;
CopyMemory(appWindow->windowRects, windowState->windowRects,
appWindow->numWindowRects * sizeof(RECTANGLE_16));
appWindow->visibilityRects = (RECTANGLE_16*) calloc(appWindow->numVisibilityRects, sizeof(RECTANGLE_16));
if (!appWindow->visibilityRects)
- return;
+ return FALSE;
CopyMemory(appWindow->visibilityRects, windowState->visibilityRects,
appWindow->numVisibilityRects * sizeof(RECTANGLE_16));
* update our local window when that rail window state is minimized
*/
if (appWindow->rail_state == WINDOW_SHOW_MINIMIZED)
- return;
+ return TRUE;
/* Do nothing if window is already in the correct position */
if (appWindow->x == (appWindow->windowOffsetX - appWindow->localWindowOffsetCorrX) &&
appWindow->height == appWindow->windowHeight)
{
xf_UpdateWindowArea(xfc, appWindow, 0, 0, appWindow->windowWidth, appWindow->windowHeight);
- return;
+ return TRUE;
}
xf_MoveWindow(xfc, appWindow, appWindow->windowOffsetX - appWindow->localWindowOffsetCorrX, appWindow->windowOffsetY - appWindow->localWindowOffsetCorrY,
{
xf_SetWindowVisibilityRects(xfc, appWindow, appWindow->visibilityRects, appWindow->numVisibilityRects);
}
+ return TRUE;
}
-static void xf_rail_window_delete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL xf_rail_window_delete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
xfAppWindow* appWindow = NULL;
xfContext* xfc = (xfContext*) context;
(void*) (UINT_PTR) orderInfo->windowId);
if (!appWindow)
- return;
+ return TRUE;
HashTable_Remove(xfc->railWindows, (void*) (UINT_PTR) orderInfo->windowId);
xf_DestroyWindow(xfc, appWindow);
+ return TRUE;
}
-static void xf_rail_window_icon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* windowIcon)
+static BOOL xf_rail_window_icon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* windowIcon)
{
BOOL bigIcon;
xfAppWindow* railWindow;
(void*) (UINT_PTR) orderInfo->windowId);
if (!railWindow)
- return;
+ return FALSE;
bigIcon = (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_ICON_BIG) ? TRUE : FALSE;
+
+ return TRUE;
}
-static void xf_rail_window_cached_icon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
+static BOOL xf_rail_window_cached_icon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
{
-
+ return TRUE;
}
-static void xf_rail_notify_icon_common(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
+static BOOL xf_rail_notify_icon_common(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
{
if (orderInfo->fieldFlags & WINDOW_ORDER_FIELD_NOTIFY_VERSION)
{
{
}
+ return TRUE;
}
-static void xf_rail_notify_icon_create(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
+static BOOL xf_rail_notify_icon_create(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
{
- xf_rail_notify_icon_common(context, orderInfo, notifyIconState);
+ return xf_rail_notify_icon_common(context, orderInfo, notifyIconState);
}
-static void xf_rail_notify_icon_update(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
+static BOOL xf_rail_notify_icon_update(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
{
- xf_rail_notify_icon_common(context, orderInfo, notifyIconState);
+ return xf_rail_notify_icon_common(context, orderInfo, notifyIconState);
}
-static void xf_rail_notify_icon_delete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL xf_rail_notify_icon_delete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
-
+ return TRUE;
}
-static void xf_rail_monitored_desktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, MONITORED_DESKTOP_ORDER* monitoredDesktop)
+static BOOL xf_rail_monitored_desktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, MONITORED_DESKTOP_ORDER* monitoredDesktop)
{
-
+ return TRUE;
}
-static void xf_rail_non_monitored_desktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL xf_rail_non_monitored_desktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
xfContext* xfc = (xfContext*) context;
xf_rail_disable_remoteapp_mode(xfc);
+ return TRUE;
}
void xf_rail_register_update_callbacks(rdpUpdate* update)
#import "ios_freerdp.h"
-void ios_ui_begin_paint(rdpContext * context);
-void ios_ui_end_paint(rdpContext * context);
-void ios_ui_resize_window(rdpContext * context);
+BOOL ios_ui_begin_paint(rdpContext * context);
+BOOL ios_ui_end_paint(rdpContext * context);
+BOOL ios_ui_resize_window(rdpContext * context);
BOOL ios_ui_authenticate(freerdp * instance, char** username, char** password, char** domain);
BOOL ios_ui_check_certificate(freerdp * instance, char * subject, char * issuer, char * fingerprint);
#pragma mark -
#pragma mark Graphics updates
-void ios_ui_begin_paint(rdpContext * context)
+BOOL ios_ui_begin_paint(rdpContext * context)
{
rdpGdi *gdi = context->gdi;
gdi->primary->hdc->hwnd->invalid->null = 1;
+ return TRUE;
}
-void ios_ui_end_paint(rdpContext * context)
+BOOL ios_ui_end_paint(rdpContext * context)
{
mfInfo* mfi = MFI_FROM_INSTANCE(context->instance);
rdpGdi *gdi = context->gdi;
if (gdi->primary->hdc->hwnd->invalid->null == 0)
[mfi->session performSelectorOnMainThread:@selector(setNeedsDisplayInRectAsValue:) withObject:[NSValue valueWithCGRect:dirty_rect] waitUntilDone:NO];
+ return TRUE;
}
-void ios_ui_resize_window(rdpContext * context)
+BOOL ios_ui_resize_window(rdpContext * context)
{
ios_resize_display_buffer(MFI_FROM_INSTANCE(context->instance));
+ return TRUE;
}
};
typedef struct _DRAW_GDIPLUS_CACHE_END_ORDER DRAW_GDIPLUS_CACHE_END_ORDER;
-typedef void (*pCreateOffscreenBitmap)(rdpContext* context, CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap);
-typedef void (*pSwitchSurface)(rdpContext* context, SWITCH_SURFACE_ORDER* switch_surface);
-typedef void (*pCreateNineGridBitmap)(rdpContext* context, CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap);
-typedef void (*pFrameMarker)(rdpContext* context, FRAME_MARKER_ORDER* frame_marker);
-typedef void (*pStreamBitmapFirst)(rdpContext* context, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first);
-typedef void (*pStreamBitmapNext)(rdpContext* context, STREAM_BITMAP_NEXT_ORDER* stream_bitmap_next);
-typedef void (*pDrawGdiPlusFirst)(rdpContext* context, DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first);
-typedef void (*pDrawGdiPlusNext)(rdpContext* context, DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next);
-typedef void (*pDrawGdiPlusEnd)(rdpContext* context, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end);
-typedef void (*pDrawGdiPlusCacheFirst)(rdpContext* context, DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first);
-typedef void (*pDrawGdiPlusCacheNext)(rdpContext* context, DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next);
-typedef void (*pDrawGdiPlusCacheEnd)(rdpContext* context, DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end);
+typedef BOOL (*pCreateOffscreenBitmap)(rdpContext* context, CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap);
+typedef BOOL (*pSwitchSurface)(rdpContext* context, SWITCH_SURFACE_ORDER* switch_surface);
+typedef BOOL (*pCreateNineGridBitmap)(rdpContext* context, CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap);
+typedef BOOL (*pFrameMarker)(rdpContext* context, FRAME_MARKER_ORDER* frame_marker);
+typedef BOOL (*pStreamBitmapFirst)(rdpContext* context, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first);
+typedef BOOL (*pStreamBitmapNext)(rdpContext* context, STREAM_BITMAP_NEXT_ORDER* stream_bitmap_next);
+typedef BOOL (*pDrawGdiPlusFirst)(rdpContext* context, DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first);
+typedef BOOL (*pDrawGdiPlusNext)(rdpContext* context, DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next);
+typedef BOOL (*pDrawGdiPlusEnd)(rdpContext* context, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end);
+typedef BOOL (*pDrawGdiPlusCacheFirst)(rdpContext* context, DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first);
+typedef BOOL (*pDrawGdiPlusCacheNext)(rdpContext* context, DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next);
+typedef BOOL (*pDrawGdiPlusCacheEnd)(rdpContext* context, DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end);
struct rdp_altsec_update
{
#define IFCALL(_cb, ...) do { if (_cb != NULL) { _cb( __VA_ARGS__ ); } } while (0)
#define IFCALLRET(_cb, _ret, ...) do { if (_cb != NULL) { _ret = _cb( __VA_ARGS__ ); } } while (0)
+#define IFCALLRETURN(_default_return, _cb, ...) do { if (_cb != NULL) { return _cb( __VA_ARGS__ ); } else { return _default_return;} } while (0)
#endif /* FREERDP_API */
* Client Entry Points
*/
-typedef void (*pRdpGlobalInit)(void);
+typedef BOOL (*pRdpGlobalInit)(void);
typedef void (*pRdpGlobalUninit)(void);
typedef int (*pRdpClientNew)(freerdp* instance, rdpContext* context);
/* Bitmap Class */
-typedef void (*pBitmap_New)(rdpContext* context, rdpBitmap* bitmap);
+typedef BOOL (*pBitmap_New)(rdpContext* context, rdpBitmap* bitmap);
typedef void (*pBitmap_Free)(rdpContext* context, rdpBitmap* bitmap);
-typedef void (*pBitmap_Paint)(rdpContext* context, rdpBitmap* bitmap);
-typedef void (*pBitmap_Decompress)(rdpContext* context, rdpBitmap* bitmap,
+typedef BOOL (*pBitmap_Paint)(rdpContext* context, rdpBitmap* bitmap);
+typedef BOOL (*pBitmap_Decompress)(rdpContext* context, rdpBitmap* bitmap,
BYTE* data, int width, int height, int bpp, int length,
BOOL compressed, int codec_id);
-typedef void (*pBitmap_SetSurface)(rdpContext* context, rdpBitmap* bitmap, BOOL primary);
+typedef BOOL (*pBitmap_SetSurface)(rdpContext* context, rdpBitmap* bitmap, BOOL primary);
struct rdp_bitmap
{
};
FREERDP_API rdpBitmap* Bitmap_Alloc(rdpContext* context);
-FREERDP_API void Bitmap_New(rdpContext* context, rdpBitmap* bitmap);
+FREERDP_API BOOL Bitmap_New(rdpContext* context, rdpBitmap* bitmap);
FREERDP_API void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap);
-FREERDP_API void Bitmap_Register(rdpContext* context, rdpBitmap* bitmap);
-FREERDP_API void Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
+FREERDP_API BOOL Bitmap_Register(rdpContext* context, rdpBitmap* bitmap);
+FREERDP_API BOOL Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
BYTE* data, int width, int height, int bpp, int length, BOOL compressed);
FREERDP_API void Bitmap_SetRectangle(rdpContext* context, rdpBitmap* bitmap,
UINT16 left, UINT16 top, UINT16 right, UINT16 bottom);
FREERDP_API void Bitmap_SetDimensions(rdpContext* context, rdpBitmap* bitmap, UINT16 width, UINT16 height);
-FREERDP_API void Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary);
+FREERDP_API BOOL Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary);
/* Pointer Class */
-typedef void (*pPointer_New)(rdpContext* context, rdpPointer* pointer);
+typedef BOOL (*pPointer_New)(rdpContext* context, rdpPointer* pointer);
typedef void (*pPointer_Free)(rdpContext* context, rdpPointer* pointer);
-typedef void (*pPointer_Set)(rdpContext* context, rdpPointer* pointer);
-typedef void (*pPointer_SetNull)(rdpContext* context);
-typedef void (*pPointer_SetDefault)(rdpContext* context);
-typedef void (*pPointer_SetPosition)(rdpContext* context, UINT32 x, UINT32 y);
+typedef BOOL (*pPointer_Set)(rdpContext* context, rdpPointer* pointer);
+typedef BOOL (*pPointer_SetNull)(rdpContext* context);
+typedef BOOL (*pPointer_SetDefault)(rdpContext* context);
+typedef BOOL (*pPointer_SetPosition)(rdpContext* context, UINT32 x, UINT32 y);
struct rdp_pointer
{
};
FREERDP_API rdpPointer* Pointer_Alloc(rdpContext* context);
-FREERDP_API void Pointer_New(rdpContext* context, rdpPointer* pointer);
+FREERDP_API BOOL Pointer_New(rdpContext* context, rdpPointer* pointer);
FREERDP_API void Pointer_Free(rdpContext* context, rdpPointer* pointer);
-FREERDP_API void Pointer_Set(rdpContext* context, rdpPointer* pointer);
-FREERDP_API void Pointer_SetNull(rdpContext* context);
-FREERDP_API void Pointer_SetDefault(rdpContext* context);
-FREERDP_API void Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y);
+FREERDP_API BOOL Pointer_Set(rdpContext* context, rdpPointer* pointer);
+FREERDP_API BOOL Pointer_SetNull(rdpContext* context);
+FREERDP_API BOOL Pointer_SetDefault(rdpContext* context);
+FREERDP_API BOOL Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y);
/* Glyph Class */
-typedef void (*pGlyph_New)(rdpContext* context, rdpGlyph* glyph);
+typedef BOOL (*pGlyph_New)(rdpContext* context, rdpGlyph* glyph);
typedef void (*pGlyph_Free)(rdpContext* context, rdpGlyph* glyph);
-typedef void (*pGlyph_Draw)(rdpContext* context, rdpGlyph* glyph, int x, int y);
-typedef void (*pGlyph_BeginDraw)(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant);
-typedef void (*pGlyph_EndDraw)(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor);
+typedef BOOL (*pGlyph_Draw)(rdpContext* context, rdpGlyph* glyph, int x, int y);
+typedef BOOL (*pGlyph_BeginDraw)(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant);
+typedef BOOL (*pGlyph_EndDraw)(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor);
struct rdp_glyph
{
};
FREERDP_API rdpGlyph* Glyph_Alloc(rdpContext* context);
-FREERDP_API void Glyph_New(rdpContext* context, rdpGlyph* glyph);
+FREERDP_API BOOL Glyph_New(rdpContext* context, rdpGlyph* glyph);
FREERDP_API void Glyph_Free(rdpContext* context, rdpGlyph* glyph);
-FREERDP_API void Glyph_Draw(rdpContext* context, rdpGlyph* glyph, int x, int y);
-FREERDP_API void Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant);
-FREERDP_API void Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor);
+FREERDP_API BOOL Glyph_Draw(rdpContext* context, rdpGlyph* glyph, int x, int y);
+FREERDP_API BOOL Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant);
+FREERDP_API BOOL Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor);
/* Graphics Module */
/* Input Interface */
-typedef void (*pSynchronizeEvent)(rdpInput* input, UINT32 flags);
-typedef void (*pKeyboardEvent)(rdpInput* input, UINT16 flags, UINT16 code);
-typedef void (*pUnicodeKeyboardEvent)(rdpInput* input, UINT16 flags, UINT16 code);
-typedef void (*pMouseEvent)(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
-typedef void (*pExtendedMouseEvent)(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
-typedef void (*pFocusInEvent)(rdpInput* input, UINT16 toggleStates);
-typedef void (*pKeyboardPauseEvent)(rdpInput* input);
+typedef BOOL (*pSynchronizeEvent)(rdpInput* input, UINT32 flags);
+typedef BOOL (*pKeyboardEvent)(rdpInput* input, UINT16 flags, UINT16 code);
+typedef BOOL (*pUnicodeKeyboardEvent)(rdpInput* input, UINT16 flags, UINT16 code);
+typedef BOOL (*pMouseEvent)(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+typedef BOOL (*pExtendedMouseEvent)(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+typedef BOOL (*pFocusInEvent)(rdpInput* input, UINT16 toggleStates);
+typedef BOOL (*pKeyboardPauseEvent)(rdpInput* input);
struct rdp_input
{
extern "C" {
#endif
-FREERDP_API void freerdp_input_send_synchronize_event(rdpInput* input, UINT32 flags);
-FREERDP_API void freerdp_input_send_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
-FREERDP_API void freerdp_input_send_keyboard_event_ex(rdpInput* input, BOOL down, UINT32 rdp_scancode);
-FREERDP_API void freerdp_input_send_keyboard_pause_event(rdpInput* input);
-FREERDP_API void freerdp_input_send_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
-FREERDP_API void freerdp_input_send_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
-FREERDP_API void freerdp_input_send_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
-FREERDP_API void freerdp_input_send_focus_in_event(rdpInput* input, UINT16 toggleStates);
+FREERDP_API BOOL freerdp_input_send_synchronize_event(rdpInput* input, UINT32 flags);
+FREERDP_API BOOL freerdp_input_send_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
+FREERDP_API BOOL freerdp_input_send_keyboard_event_ex(rdpInput* input, BOOL down, UINT32 rdp_scancode);
+FREERDP_API BOOL freerdp_input_send_keyboard_pause_event(rdpInput* input);
+FREERDP_API BOOL freerdp_input_send_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
+FREERDP_API BOOL freerdp_input_send_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+FREERDP_API BOOL freerdp_input_send_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+FREERDP_API BOOL freerdp_input_send_focus_in_event(rdpInput* input, UINT16 toggleStates);
#ifdef __cplusplus
}
};
typedef struct _POINTER_CACHED_UPDATE POINTER_CACHED_UPDATE;
-typedef void (*pPointerPosition)(rdpContext* context, POINTER_POSITION_UPDATE* pointer_position);
-typedef void (*pPointerSystem)(rdpContext* context, POINTER_SYSTEM_UPDATE* pointer_system);
-typedef void (*pPointerColor)(rdpContext* context, POINTER_COLOR_UPDATE* pointer_color);
-typedef void (*pPointerNew)(rdpContext* context, POINTER_NEW_UPDATE* pointer_new);
-typedef void (*pPointerCached)(rdpContext* context, POINTER_CACHED_UPDATE* pointer_cached);
+typedef BOOL (*pPointerPosition)(rdpContext* context, POINTER_POSITION_UPDATE* pointer_position);
+typedef BOOL (*pPointerSystem)(rdpContext* context, POINTER_SYSTEM_UPDATE* pointer_system);
+typedef BOOL (*pPointerColor)(rdpContext* context, POINTER_COLOR_UPDATE* pointer_color);
+typedef BOOL (*pPointerNew)(rdpContext* context, POINTER_NEW_UPDATE* pointer_new);
+typedef BOOL (*pPointerCached)(rdpContext* context, POINTER_CACHED_UPDATE* pointer_cached);
struct rdp_pointer_update
{
};
typedef struct _ELLIPSE_CB_ORDER ELLIPSE_CB_ORDER;
-typedef void (*pDstBlt)(rdpContext* context, DSTBLT_ORDER* dstblt);
-typedef void (*pPatBlt)(rdpContext* context, PATBLT_ORDER* patblt);
-typedef void (*pScrBlt)(rdpContext* context, SCRBLT_ORDER* scrblt);
-typedef void (*pOpaqueRect)(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect);
-typedef void (*pDrawNineGrid)(rdpContext* context, DRAW_NINE_GRID_ORDER* draw_nine_grid);
-typedef void (*pMultiDstBlt)(rdpContext* context, MULTI_DSTBLT_ORDER* multi_dstblt);
-typedef void (*pMultiPatBlt)(rdpContext* context, MULTI_PATBLT_ORDER* multi_patblt);
-typedef void (*pMultiScrBlt)(rdpContext* context, MULTI_SCRBLT_ORDER* multi_scrblt);
-typedef void (*pMultiOpaqueRect)(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect);
-typedef void (*pMultiDrawNineGrid)(rdpContext* context, MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid);
-typedef void (*pLineTo)(rdpContext* context, LINE_TO_ORDER* line_to);
-typedef void (*pPolyline)(rdpContext* context, POLYLINE_ORDER* polyline);
-typedef void (*pMemBlt)(rdpContext* context, MEMBLT_ORDER* memblt);
-typedef void (*pMem3Blt)(rdpContext* context, MEM3BLT_ORDER* memblt);
-typedef void (*pSaveBitmap)(rdpContext* context, SAVE_BITMAP_ORDER* save_bitmap);
-typedef void (*pGlyphIndex)(rdpContext* context, GLYPH_INDEX_ORDER* glyph_index);
-typedef void (*pFastIndex)(rdpContext* context, FAST_INDEX_ORDER* fast_index);
-typedef void (*pFastGlyph)(rdpContext* context, FAST_GLYPH_ORDER* fast_glyph);
-typedef void (*pPolygonSC)(rdpContext* context, POLYGON_SC_ORDER* polygon_sc);
-typedef void (*pPolygonCB)(rdpContext* context, POLYGON_CB_ORDER* polygon_cb);
-typedef void (*pEllipseSC)(rdpContext* context, ELLIPSE_SC_ORDER* ellipse_sc);
-typedef void (*pEllipseCB)(rdpContext* context, ELLIPSE_CB_ORDER* ellipse_cb);
+typedef BOOL (*pDstBlt)(rdpContext* context, DSTBLT_ORDER* dstblt);
+typedef BOOL (*pPatBlt)(rdpContext* context, PATBLT_ORDER* patblt);
+typedef BOOL (*pScrBlt)(rdpContext* context, SCRBLT_ORDER* scrblt);
+typedef BOOL (*pOpaqueRect)(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect);
+typedef BOOL (*pDrawNineGrid)(rdpContext* context, DRAW_NINE_GRID_ORDER* draw_nine_grid);
+typedef BOOL (*pMultiDstBlt)(rdpContext* context, MULTI_DSTBLT_ORDER* multi_dstblt);
+typedef BOOL (*pMultiPatBlt)(rdpContext* context, MULTI_PATBLT_ORDER* multi_patblt);
+typedef BOOL (*pMultiScrBlt)(rdpContext* context, MULTI_SCRBLT_ORDER* multi_scrblt);
+typedef BOOL (*pMultiOpaqueRect)(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect);
+typedef BOOL (*pMultiDrawNineGrid)(rdpContext* context, MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid);
+typedef BOOL (*pLineTo)(rdpContext* context, LINE_TO_ORDER* line_to);
+typedef BOOL (*pPolyline)(rdpContext* context, POLYLINE_ORDER* polyline);
+typedef BOOL (*pMemBlt)(rdpContext* context, MEMBLT_ORDER* memblt);
+typedef BOOL (*pMem3Blt)(rdpContext* context, MEM3BLT_ORDER* memblt);
+typedef BOOL (*pSaveBitmap)(rdpContext* context, SAVE_BITMAP_ORDER* save_bitmap);
+typedef BOOL (*pGlyphIndex)(rdpContext* context, GLYPH_INDEX_ORDER* glyph_index);
+typedef BOOL (*pFastIndex)(rdpContext* context, FAST_INDEX_ORDER* fast_index);
+typedef BOOL (*pFastGlyph)(rdpContext* context, FAST_GLYPH_ORDER* fast_glyph);
+typedef BOOL (*pPolygonSC)(rdpContext* context, POLYGON_SC_ORDER* polygon_sc);
+typedef BOOL (*pPolygonCB)(rdpContext* context, POLYGON_CB_ORDER* polygon_cb);
+typedef BOOL (*pEllipseSC)(rdpContext* context, ELLIPSE_SC_ORDER* ellipse_sc);
+typedef BOOL (*pEllipseCB)(rdpContext* context, ELLIPSE_CB_ORDER* ellipse_cb);
struct rdp_primary_update
{
};
typedef struct _CACHE_BRUSH_ORDER CACHE_BRUSH_ORDER;
-typedef void (*pCacheBitmap)(rdpContext* context, CACHE_BITMAP_ORDER* cache_bitmap_order);
-typedef void (*pCacheBitmapV2)(rdpContext* context, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2_order);
-typedef void (*pCacheBitmapV3)(rdpContext* context, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3_order);
-typedef void (*pCacheColorTable)(rdpContext* context, CACHE_COLOR_TABLE_ORDER* cache_color_table_order);
-typedef void (*pCacheGlyph)(rdpContext* context, CACHE_GLYPH_ORDER* cache_glyph_order);
-typedef void (*pCacheGlyphV2)(rdpContext* context, CACHE_GLYPH_V2_ORDER* cache_glyph_v2_order);
-typedef void (*pCacheBrush)(rdpContext* context, CACHE_BRUSH_ORDER* cache_brush_order);
+typedef BOOL (*pCacheBitmap)(rdpContext* context, CACHE_BITMAP_ORDER* cache_bitmap_order);
+typedef BOOL (*pCacheBitmapV2)(rdpContext* context, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2_order);
+typedef BOOL (*pCacheBitmapV3)(rdpContext* context, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3_order);
+typedef BOOL (*pCacheColorTable)(rdpContext* context, CACHE_COLOR_TABLE_ORDER* cache_color_table_order);
+typedef BOOL (*pCacheGlyph)(rdpContext* context, CACHE_GLYPH_ORDER* cache_glyph_order);
+typedef BOOL (*pCacheGlyphV2)(rdpContext* context, CACHE_GLYPH_V2_ORDER* cache_glyph_v2_order);
+typedef BOOL (*pCacheBrush)(rdpContext* context, CACHE_BRUSH_ORDER* cache_brush_order);
struct rdp_secondary_update
{
/* Update Interface */
-typedef void (*pBeginPaint)(rdpContext* context);
-typedef void (*pEndPaint)(rdpContext* context);
-typedef void (*pSetBounds)(rdpContext* context, rdpBounds* bounds);
-
-typedef void (*pSynchronize)(rdpContext* context);
-typedef void (*pDesktopResize)(rdpContext* context);
-typedef void (*pBitmapUpdate)(rdpContext* context, BITMAP_UPDATE* bitmap);
-typedef void (*pPalette)(rdpContext* context, PALETTE_UPDATE* palette);
-typedef void (*pPlaySound)(rdpContext* context, PLAY_SOUND_UPDATE* play_sound);
-typedef void (*pSetKeyboardIndicators)(rdpContext* context, UINT16 led_flags);
-
-typedef void (*pRefreshRect)(rdpContext* context, BYTE count, RECTANGLE_16* areas);
-typedef void (*pSuppressOutput)(rdpContext* context, BYTE allow, RECTANGLE_16* area);
-
-typedef void (*pSurfaceCommand)(rdpContext* context, wStream* s);
-typedef void (*pSurfaceBits)(rdpContext* context, SURFACE_BITS_COMMAND* surfaceBitsCommand);
-typedef void (*pSurfaceFrameMarker)(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker);
-typedef void (*pSurfaceFrameBits)(rdpContext* context, SURFACE_BITS_COMMAND* cmd, BOOL first, BOOL last, UINT32 frameId);
-typedef void (*pSurfaceFrameAcknowledge)(rdpContext* context, UINT32 frameId);
+typedef BOOL (*pBeginPaint)(rdpContext* context);
+typedef BOOL (*pEndPaint)(rdpContext* context);
+typedef BOOL (*pSetBounds)(rdpContext* context, rdpBounds* bounds);
+
+typedef BOOL (*pSynchronize)(rdpContext* context);
+typedef BOOL (*pDesktopResize)(rdpContext* context);
+typedef BOOL (*pBitmapUpdate)(rdpContext* context, BITMAP_UPDATE* bitmap);
+typedef BOOL (*pPalette)(rdpContext* context, PALETTE_UPDATE* palette);
+typedef BOOL (*pPlaySound)(rdpContext* context, PLAY_SOUND_UPDATE* play_sound);
+typedef BOOL (*pSetKeyboardIndicators)(rdpContext* context, UINT16 led_flags);
+
+typedef BOOL (*pRefreshRect)(rdpContext* context, BYTE count, RECTANGLE_16* areas);
+typedef BOOL (*pSuppressOutput)(rdpContext* context, BYTE allow, RECTANGLE_16* area);
+
+typedef BOOL (*pSurfaceCommand)(rdpContext* context, wStream* s);
+typedef BOOL (*pSurfaceBits)(rdpContext* context, SURFACE_BITS_COMMAND* surfaceBitsCommand);
+typedef BOOL (*pSurfaceFrameMarker)(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker);
+typedef BOOL (*pSurfaceFrameBits)(rdpContext* context, SURFACE_BITS_COMMAND* cmd, BOOL first, BOOL last, UINT32 frameId);
+typedef BOOL (*pSurfaceFrameAcknowledge)(rdpContext* context, UINT32 frameId);
struct rdp_update
{
};
typedef struct _MONITORED_DESKTOP_ORDER MONITORED_DESKTOP_ORDER;
-typedef void (*pWindowCreate)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* window_state);
-typedef void (*pWindowUpdate)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* window_state);
-typedef void (*pWindowIcon)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* window_icon);
-typedef void (*pWindowCachedIcon)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_CACHED_ICON_ORDER* window_cached_icon);
-typedef void (*pWindowDelete)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo);
-typedef void (*pNotifyIconCreate)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notify_icon_state);
-typedef void (*pNotifyIconUpdate)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notify_icon_state);
-typedef void (*pNotifyIconDelete)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo);
-typedef void (*pMonitoredDesktop)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, MONITORED_DESKTOP_ORDER* monitored_desktop);
-typedef void (*pNonMonitoredDesktop)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo);
+typedef BOOL (*pWindowCreate)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* window_state);
+typedef BOOL (*pWindowUpdate)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* window_state);
+typedef BOOL (*pWindowIcon)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* window_icon);
+typedef BOOL (*pWindowCachedIcon)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_CACHED_ICON_ORDER* window_cached_icon);
+typedef BOOL (*pWindowDelete)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo);
+typedef BOOL (*pNotifyIconCreate)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notify_icon_state);
+typedef BOOL (*pNotifyIconUpdate)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notify_icon_state);
+typedef BOOL (*pNotifyIconDelete)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo);
+typedef BOOL (*pMonitoredDesktop)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, MONITORED_DESKTOP_ORDER* monitored_desktop);
+typedef BOOL (*pNonMonitoredDesktop)(rdpContext* context, WINDOW_ORDER_INFO* orderInfo);
struct rdp_window_update
{
#define TAG FREERDP_TAG("cache.bitmap")
-void update_gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
+BOOL update_gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
{
rdpBitmap* bitmap;
rdpCache* cache = context->cache;
else
bitmap = bitmap_cache_get(cache->bitmap, (BYTE) memblt->cacheId, memblt->cacheIndex);
/* XP-SP2 servers sometimes ask for cached bitmaps they've never defined. */
- if (bitmap == NULL) return;
+ if (bitmap == NULL)
+ return TRUE;
memblt->bitmap = bitmap;
- IFCALL(cache->bitmap->MemBlt, context, memblt);
+ IFCALLRETURN(TRUE, cache->bitmap->MemBlt, context, memblt);
}
-void update_gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
+BOOL update_gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
{
BYTE style;
rdpBitmap* bitmap;
rdpCache* cache = context->cache;
rdpBrush* brush = &mem3blt->brush;
+ BOOL ret = TRUE;
if (mem3blt->cacheId == 0xFF)
bitmap = offscreen_cache_get(cache->offscreen, mem3blt->cacheIndex);
/* XP-SP2 servers sometimes ask for cached bitmaps they've never defined. */
if (!bitmap)
- return;
+ return TRUE;
style = brush->style;
if (brush->style & CACHED_BRUSH)
{
brush->data = brush_cache_get(cache->brush, brush->index, &brush->bpp);
+ if (!brush->data)
+ return FALSE;
brush->style = 0x03;
}
mem3blt->bitmap = bitmap;
- IFCALL(cache->bitmap->Mem3Blt, context, mem3blt);
+ IFCALLRET(cache->bitmap->Mem3Blt, ret, context, mem3blt);
brush->style = style;
+ return ret;
}
-void update_gdi_cache_bitmap(rdpContext* context, CACHE_BITMAP_ORDER* cacheBitmap)
+BOOL update_gdi_cache_bitmap(rdpContext* context, CACHE_BITMAP_ORDER* cacheBitmap)
{
rdpBitmap* bitmap;
rdpBitmap* prevBitmap;
rdpCache* cache = context->cache;
bitmap = Bitmap_Alloc(context);
+ if (!bitmap)
+ return FALSE;
+
Bitmap_SetDimensions(context, bitmap, cacheBitmap->bitmapWidth, cacheBitmap->bitmapHeight);
- bitmap->Decompress(context, bitmap,
+ if (!bitmap->Decompress(context, bitmap,
cacheBitmap->bitmapDataStream, cacheBitmap->bitmapWidth, cacheBitmap->bitmapHeight,
cacheBitmap->bitmapBpp, cacheBitmap->bitmapLength,
- cacheBitmap->compressed, RDP_CODEC_ID_NONE);
+ cacheBitmap->compressed, RDP_CODEC_ID_NONE))
+ {
+ Bitmap_Free(context, bitmap);
+ return FALSE;
+ }
bitmap->New(context, bitmap);
Bitmap_Free(context, prevBitmap);
bitmap_cache_put(cache->bitmap, cacheBitmap->cacheId, cacheBitmap->cacheIndex, bitmap);
+ return TRUE;
}
-void update_gdi_cache_bitmap_v2(rdpContext* context, CACHE_BITMAP_V2_ORDER* cacheBitmapV2)
+BOOL update_gdi_cache_bitmap_v2(rdpContext* context, CACHE_BITMAP_V2_ORDER* cacheBitmapV2)
+
{
rdpBitmap* bitmap;
rdpBitmap* prevBitmap;
rdpSettings* settings = context->settings;
bitmap = Bitmap_Alloc(context);
+ if (!bitmap)
+ return FALSE;
Bitmap_SetDimensions(context, bitmap, cacheBitmapV2->bitmapWidth, cacheBitmapV2->bitmapHeight);
if ((settings->ColorDepth == 15) && (cacheBitmapV2->bitmapBpp == 16))
cacheBitmapV2->bitmapBpp = settings->ColorDepth;
- bitmap->Decompress(context, bitmap,
+ if (!bitmap->Decompress(context, bitmap,
cacheBitmapV2->bitmapDataStream, cacheBitmapV2->bitmapWidth, cacheBitmapV2->bitmapHeight,
cacheBitmapV2->bitmapBpp, cacheBitmapV2->bitmapLength,
- cacheBitmapV2->compressed, RDP_CODEC_ID_NONE);
+ cacheBitmapV2->compressed, RDP_CODEC_ID_NONE))
+ {
+ Bitmap_Free(context, bitmap);
+ return FALSE;
+ }
bitmap->New(context, bitmap);
Bitmap_Free(context, prevBitmap);
bitmap_cache_put(cache->bitmap, cacheBitmapV2->cacheId, cacheBitmapV2->cacheIndex, bitmap);
+ return TRUE;
}
-void update_gdi_cache_bitmap_v3(rdpContext* context, CACHE_BITMAP_V3_ORDER* cacheBitmapV3)
+BOOL update_gdi_cache_bitmap_v3(rdpContext* context, CACHE_BITMAP_V3_ORDER* cacheBitmapV3)
{
rdpBitmap* bitmap;
rdpBitmap* prevBitmap;
BITMAP_DATA_EX* bitmapData = &cacheBitmapV3->bitmapData;
bitmap = Bitmap_Alloc(context);
+ if (!bitmap)
+ return FALSE;
Bitmap_SetDimensions(context, bitmap, bitmapData->width, bitmapData->height);
Bitmap_Free(context, prevBitmap);
bitmap_cache_put(cache->bitmap, cacheBitmapV3->cacheId, cacheBitmapV3->cacheIndex, bitmap);
+ return TRUE;
}
-void update_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
+BOOL update_gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
{
int i;
BOOL reused = TRUE;
bitmap->Paint(context, bitmap);
}
+ return TRUE;
}
rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index)
#define TAG FREERDP_TAG("cache.brush")
-void update_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
+BOOL update_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
{
BYTE style;
+ BOOL ret = TRUE;
rdpBrush* brush = &patblt->brush;
rdpCache* cache = context->cache;
brush->style = 0x03;
}
- IFCALL(cache->brush->PatBlt, context, patblt);
+ IFCALLRET(cache->brush->PatBlt, ret, context, patblt);
brush->style = style;
+ return ret;
}
-void update_gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc)
+BOOL update_gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc)
{
rdpCache* cache = context->cache;
- IFCALL(cache->brush->PolygonSC, context, polygon_sc);
+ IFCALLRETURN(TRUE, cache->brush->PolygonSC, context, polygon_sc);
}
-void update_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
+BOOL update_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
{
BYTE style;
rdpBrush* brush = &polygon_cb->brush;
rdpCache* cache = context->cache;
+ BOOL ret = TRUE;
style = brush->style;
brush->style = 0x03;
}
- IFCALL(cache->brush->PolygonCB, context, polygon_cb);
+ IFCALLRET(cache->brush->PolygonCB, ret, context, polygon_cb);
brush->style = style;
+ return ret;
}
-static void update_gdi_cache_brush(rdpContext* context, CACHE_BRUSH_ORDER* cacheBrush)
+static BOOL update_gdi_cache_brush(rdpContext* context, CACHE_BRUSH_ORDER* cacheBrush)
{
int length;
void* data = NULL;
length = cacheBrush->bpp * 64 / 8;
data = malloc(length);
+ if (!data)
+ return FALSE;
CopyMemory(data, cacheBrush->data, length);
brush_cache_put(cache->brush, cacheBrush->index, data, cacheBrush->bpp);
+ return TRUE;
}
void* brush_cache_get(rdpBrushCache* brushCache, UINT32 index, UINT32* bpp)
Glyph_EndDraw(context, bkX, bkY, bkWidth, bkHeight, bgcolor, fgcolor);
}
-void update_gdi_glyph_index(rdpContext* context, GLYPH_INDEX_ORDER* glyphIndex)
+BOOL update_gdi_glyph_index(rdpContext* context, GLYPH_INDEX_ORDER* glyphIndex)
{
rdpGlyphCache* glyph_cache;
int bkWidth, bkHeight, opWidth, opHeight;
glyphIndex->bkLeft, glyphIndex->bkTop, bkWidth, bkHeight,
glyphIndex->opLeft, glyphIndex->opTop, opWidth, opHeight,
glyphIndex->fOpRedundant);
+
+ return TRUE;
}
-void update_gdi_fast_index(rdpContext* context, FAST_INDEX_ORDER* fastIndex)
+BOOL update_gdi_fast_index(rdpContext* context, FAST_INDEX_ORDER* fastIndex)
{
INT32 x, y;
INT32 opLeft, opTop;
opLeft, opTop,
opRight - opLeft, opBottom - opTop,
FALSE);
+ return TRUE;
}
-void update_gdi_fast_glyph(rdpContext* context, FAST_GLYPH_ORDER* fastGlyph)
+BOOL update_gdi_fast_glyph(rdpContext* context, FAST_GLYPH_ORDER* fastGlyph)
{
INT32 x, y;
rdpGlyph* glyph;
opLeft, opTop,
opRight - opLeft, opBottom - opTop,
FALSE);
+ return TRUE;
}
-void update_gdi_cache_glyph(rdpContext* context, CACHE_GLYPH_ORDER* cacheGlyph)
+BOOL update_gdi_cache_glyph(rdpContext* context, CACHE_GLYPH_ORDER* cacheGlyph)
{
int i;
rdpGlyph* glyph;
glyph_data = &cacheGlyph->glyphData[i];
glyph = Glyph_Alloc(context);
+ if (!glyph)
+ {
+ /* TODO: cleanup previously allocated memory */
+ return FALSE;
+ }
glyph->x = glyph_data->x;
glyph->y = glyph_data->y;
glyph_cache_put(cache->glyph, cacheGlyph->cacheId, glyph_data->cacheIndex, glyph);
}
+ return TRUE;
}
-void update_gdi_cache_glyph_v2(rdpContext* context, CACHE_GLYPH_V2_ORDER* cacheGlyphV2)
+BOOL update_gdi_cache_glyph_v2(rdpContext* context, CACHE_GLYPH_V2_ORDER* cacheGlyphV2)
{
int i;
rdpGlyph* glyph;
glyphData = &cacheGlyphV2->glyphData[i];
glyph = Glyph_Alloc(context);
+ if (!glyph)
+ {
+ /* TODO: cleanup perviosly allocated glyph memory in error case */
+ return FALSE;
+ }
glyph->x = glyphData->x;
glyph->y = glyphData->y;
glyph_cache_put(cache->glyph, cacheGlyphV2->cacheId, glyphData->cacheIndex, glyph);
}
+ return TRUE;
}
rdpGlyph* glyph_cache_get(rdpGlyphCache* glyphCache, UINT32 id, UINT32 index)
#define TAG FREERDP_TAG("cache.nine_grid")
-void update_gdi_draw_nine_grid(rdpContext* context, DRAW_NINE_GRID_ORDER* draw_nine_grid)
+BOOL update_gdi_draw_nine_grid(rdpContext* context, DRAW_NINE_GRID_ORDER* draw_nine_grid)
{
rdpCache* cache = context->cache;
- IFCALL(cache->nine_grid->DrawNineGrid, context, draw_nine_grid);
+ IFCALLRETURN(TRUE, cache->nine_grid->DrawNineGrid, context, draw_nine_grid);
}
-void update_gdi_multi_draw_nine_grid(rdpContext* context, MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
+BOOL update_gdi_multi_draw_nine_grid(rdpContext* context, MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
{
rdpCache* cache = context->cache;
- IFCALL(cache->nine_grid->MultiDrawNineGrid, context, multi_draw_nine_grid);
+ IFCALLRETURN(TRUE, cache->nine_grid->MultiDrawNineGrid, context, multi_draw_nine_grid);
}
void nine_grid_cache_register_callbacks(rdpUpdate* update)
#define TAG FREERDP_TAG("cache.offscreen")
-void update_gdi_create_offscreen_bitmap(rdpContext* context, CREATE_OFFSCREEN_BITMAP_ORDER* createOffscreenBitmap)
+BOOL update_gdi_create_offscreen_bitmap(rdpContext* context, CREATE_OFFSCREEN_BITMAP_ORDER* createOffscreenBitmap)
{
int i;
UINT16 index;
rdpCache* cache = context->cache;
bitmap = Bitmap_Alloc(context);
+ if (!bitmap)
+ return FALSE;
bitmap->width = createOffscreenBitmap->cx;
bitmap->height = createOffscreenBitmap->cy;
- bitmap->New(context, bitmap);
+ if (!bitmap->New(context, bitmap))
+ {
+ free(bitmap);
+ return FALSE;
+ }
offscreen_cache_delete(cache->offscreen, createOffscreenBitmap->id);
offscreen_cache_put(cache->offscreen, createOffscreenBitmap->id, bitmap);
index = createOffscreenBitmap->deleteList.indices[i];
offscreen_cache_delete(cache->offscreen, index);
}
+ return TRUE;
}
-void update_gdi_switch_surface(rdpContext* context, SWITCH_SURFACE_ORDER* switchSurface)
+BOOL update_gdi_switch_surface(rdpContext* context, SWITCH_SURFACE_ORDER* switchSurface)
{
rdpCache* cache = context->cache;
}
cache->offscreen->currentSurface = switchSurface->bitmapId;
+ return TRUE;
}
rdpBitmap* offscreen_cache_get(rdpOffscreenCache* offscreenCache, UINT32 index)
#define TAG FREERDP_TAG("cache.palette")
-static void update_gdi_cache_color_table(rdpContext* context, CACHE_COLOR_TABLE_ORDER* cacheColorTable)
+static BOOL update_gdi_cache_color_table(rdpContext* context, CACHE_COLOR_TABLE_ORDER* cacheColorTable)
{
UINT32* colorTable;
rdpCache* cache = context->cache;
colorTable = (UINT32*) malloc(sizeof(UINT32) * 256);
+ if (!colorTable)
+ return FALSE;
CopyMemory(colorTable, cacheColorTable->colorTable, sizeof(UINT32) * 256);
palette_cache_put(cache->palette, cacheColorTable->cacheIndex, (void*) colorTable);
+ return TRUE;
}
void* palette_cache_get(rdpPaletteCache* paletteCache, UINT32 index)
#define TAG FREERDP_TAG("cache.pointer")
-void update_pointer_position(rdpContext* context, POINTER_POSITION_UPDATE* pointer_position)
+BOOL update_pointer_position(rdpContext* context, POINTER_POSITION_UPDATE* pointer_position)
{
- Pointer_SetPosition(context, pointer_position->xPos, pointer_position->yPos);
+ return Pointer_SetPosition(context, pointer_position->xPos, pointer_position->yPos);
}
-void update_pointer_system(rdpContext* context, POINTER_SYSTEM_UPDATE* pointer_system)
+BOOL update_pointer_system(rdpContext* context, POINTER_SYSTEM_UPDATE* pointer_system)
{
switch (pointer_system->type)
{
default:
WLog_ERR(TAG, "Unknown system pointer type (0x%08X)", pointer_system->type);
- break;
}
+ return TRUE;
}
-void update_pointer_color(rdpContext* context, POINTER_COLOR_UPDATE* pointer_color)
+BOOL update_pointer_color(rdpContext* context, POINTER_COLOR_UPDATE* pointer_color)
{
rdpPointer* pointer;
rdpCache* cache = context->cache;
if (pointer->lengthAndMask && pointer_color->xorMaskData)
{
pointer->andMaskData = (BYTE*) malloc(pointer->lengthAndMask);
+ if (!pointer->andMaskData)
+ goto out_fail;
+
CopyMemory(pointer->andMaskData, pointer_color->andMaskData, pointer->lengthAndMask);
}
if (pointer->lengthXorMask && pointer_color->xorMaskData)
{
pointer->xorMaskData = (BYTE*) malloc(pointer->lengthXorMask);
+ if (!pointer->xorMaskData)
+ goto out_fail;
CopyMemory(pointer->xorMaskData, pointer_color->xorMaskData, pointer->lengthXorMask);
}
pointer->New(context, pointer);
pointer_cache_put(cache->pointer, pointer_color->cacheIndex, pointer);
Pointer_Set(context, pointer);
+ return TRUE;
}
+ return FALSE;
+
+out_fail:
+ free(pointer->andMaskData);
+ free(pointer->xorMaskData);
+ free(pointer);
+ return FALSE;
}
-void update_pointer_new(rdpContext* context, POINTER_NEW_UPDATE* pointer_new)
+BOOL update_pointer_new(rdpContext* context, POINTER_NEW_UPDATE* pointer_new)
{
rdpPointer* pointer;
rdpCache* cache = context->cache;
if (pointer->lengthAndMask)
{
pointer->andMaskData = (BYTE*) malloc(pointer->lengthAndMask);
+ if (!pointer->andMaskData)
+ goto out_fail;
CopyMemory(pointer->andMaskData, pointer_new->colorPtrAttr.andMaskData, pointer->lengthAndMask);
}
pointer->New(context, pointer);
pointer_cache_put(cache->pointer, pointer_new->colorPtrAttr.cacheIndex, pointer);
Pointer_Set(context, pointer);
+ return TRUE;
}
+ return FALSE;
+
+out_fail:
+ free(pointer->andMaskData);
+ free(pointer->xorMaskData);
+ free(pointer);
+ return FALSE;
}
-void update_pointer_cached(rdpContext* context, POINTER_CACHED_UPDATE* pointer_cached)
+BOOL update_pointer_cached(rdpContext* context, POINTER_CACHED_UPDATE* pointer_cached)
{
rdpPointer* pointer;
rdpCache* cache = context->cache;
pointer = pointer_cache_get(cache->pointer, pointer_cached->cacheIndex);
if (pointer != NULL)
+ {
Pointer_Set(context, pointer);
+ return TRUE;
+ }
+ return FALSE;
}
rdpPointer* pointer_cache_get(rdpPointerCache* pointer_cache, UINT32 index)
#include <winpr/crt.h>
-#include <freerdp/api.h>
#include <freerdp/log.h>
#include <freerdp/freerdp.h>
#include <freerdp/primitives.h>
-#include <freerdp/codec/color.h>
#define TAG FREERDP_TAG("color")
wStream* fastpath_update_pdu_init(rdpFastPath* fastpath)
{
- wStream* s;
- s = transport_send_stream_init(fastpath->rdp->transport, FASTPATH_MAX_PACKET_SIZE);
- return s;
+ return transport_send_stream_init(fastpath->rdp->transport, FASTPATH_MAX_PACKET_SIZE);
}
wStream* fastpath_update_pdu_init_new(rdpFastPath* fastpath)
return bitmap;
}
-void Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
+BOOL Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
{
-
+ return TRUE;
}
void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
}
/* static method */
-void Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
+BOOL Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
{
- context->graphics->Bitmap_Prototype->SetSurface(context, bitmap, primary);
+ return context->graphics->Bitmap_Prototype->SetSurface(context, bitmap, primary);
}
void graphics_register_bitmap(rdpGraphics* graphics, rdpBitmap* bitmap)
return pointer;
}
-void Pointer_New(rdpContext* context, rdpPointer* pointer)
+BOOL Pointer_New(rdpContext* context, rdpPointer* pointer)
{
-
+ return TRUE;
}
void Pointer_Free(rdpContext* context, rdpPointer* pointer)
}
/* static method */
-void Pointer_Set(rdpContext* context, rdpPointer* pointer)
+BOOL Pointer_Set(rdpContext* context, rdpPointer* pointer)
{
- context->graphics->Pointer_Prototype->Set(context, pointer);
+ return context->graphics->Pointer_Prototype->Set(context, pointer);
}
-void Pointer_SetNull(rdpContext* context)
+BOOL Pointer_SetNull(rdpContext* context)
{
- context->graphics->Pointer_Prototype->SetNull(context);
+ return context->graphics->Pointer_Prototype->SetNull(context);
}
-void Pointer_SetDefault(rdpContext* context)
+BOOL Pointer_SetDefault(rdpContext* context)
{
- context->graphics->Pointer_Prototype->SetDefault(context);
+ return context->graphics->Pointer_Prototype->SetDefault(context);
}
-void Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y)
+BOOL Pointer_SetPosition(rdpContext* context, UINT32 x, UINT32 y)
{
- IFCALL(context->graphics->Pointer_Prototype->SetPosition, context, x, y);
+ IFCALLRETURN(TRUE, context->graphics->Pointer_Prototype->SetPosition, context, x, y);
}
void graphics_register_pointer(rdpGraphics* graphics, rdpPointer* pointer)
return glyph;
}
-void Glyph_New(rdpContext* context, rdpGlyph* glyph)
+BOOL Glyph_New(rdpContext* context, rdpGlyph* glyph)
{
- context->graphics->Glyph_Prototype->New(context, glyph);
+ return context->graphics->Glyph_Prototype->New(context, glyph);
}
void Glyph_Free(rdpContext* context, rdpGlyph* glyph)
context->graphics->Glyph_Prototype->Free(context, glyph);
}
-void Glyph_Draw(rdpContext* context, rdpGlyph* glyph, int x, int y)
+BOOL Glyph_Draw(rdpContext* context, rdpGlyph* glyph, int x, int y)
{
- context->graphics->Glyph_Prototype->Draw(context, glyph, x, y);
+ return context->graphics->Glyph_Prototype->Draw(context, glyph, x, y);
}
-void Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
+BOOL Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
{
- context->graphics->Glyph_Prototype->BeginDraw(context, x, y, width, height, bgcolor, fgcolor, fOpRedundant);
+ return context->graphics->Glyph_Prototype->BeginDraw(context, x, y, width, height, bgcolor, fgcolor, fOpRedundant);
}
-void Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor)
+BOOL Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor)
{
- context->graphics->Glyph_Prototype->EndDraw(context, x, y, width, height, bgcolor, fgcolor);
+ return context->graphics->Glyph_Prototype->EndDraw(context, x, y, width, height, bgcolor, fgcolor);
}
void graphics_register_glyph(rdpGraphics* graphics, rdpGlyph* glyph)
#define TAG FREERDP_TAG("core")
-void rdp_write_client_input_pdu_header(wStream* s, UINT16 number)
+static void rdp_write_client_input_pdu_header(wStream* s, UINT16 number)
{
Stream_Write_UINT16(s, 1); /* numberEvents (2 bytes) */
Stream_Write_UINT16(s, 0); /* pad2Octets (2 bytes) */
}
-void rdp_write_input_event_header(wStream* s, UINT32 time, UINT16 type)
+static void rdp_write_input_event_header(wStream* s, UINT32 time, UINT16 type)
{
Stream_Write_UINT32(s, time); /* eventTime (4 bytes) */
Stream_Write_UINT16(s, type); /* messageType (2 bytes) */
{
wStream* s;
s = rdp_data_pdu_init(rdp);
+ if (!s)
+ return NULL;
rdp_write_client_input_pdu_header(s, 1);
rdp_write_input_event_header(s, 0, type);
return s;
}
-void rdp_send_client_input_pdu(rdpRdp* rdp, wStream* s)
+BOOL rdp_send_client_input_pdu(rdpRdp* rdp, wStream* s)
{
- rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_INPUT, rdp->mcs->userId);
+ return rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_INPUT, rdp->mcs->userId);
}
-void input_write_synchronize_event(wStream* s, UINT32 flags)
+static void input_write_synchronize_event(wStream* s, UINT32 flags)
{
Stream_Write_UINT16(s, 0); /* pad2Octets (2 bytes) */
Stream_Write_UINT32(s, flags); /* toggleFlags (4 bytes) */
}
-void input_send_synchronize_event(rdpInput* input, UINT32 flags)
+BOOL input_send_synchronize_event(rdpInput* input, UINT32 flags)
{
wStream* s;
rdpRdp* rdp = input->context->rdp;
s = rdp_client_input_pdu_init(rdp, INPUT_EVENT_SYNC);
+ if (!s)
+ return FALSE;
input_write_synchronize_event(s, flags);
- rdp_send_client_input_pdu(rdp, s);
+ return rdp_send_client_input_pdu(rdp, s);
}
-void input_write_keyboard_event(wStream* s, UINT16 flags, UINT16 code)
+static void input_write_keyboard_event(wStream* s, UINT16 flags, UINT16 code)
{
Stream_Write_UINT16(s, flags); /* keyboardFlags (2 bytes) */
Stream_Write_UINT16(s, code); /* keyCode (2 bytes) */
Stream_Write_UINT16(s, 0); /* pad2Octets (2 bytes) */
}
-void input_send_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL input_send_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
wStream* s;
rdpRdp* rdp = input->context->rdp;
s = rdp_client_input_pdu_init(rdp, INPUT_EVENT_SCANCODE);
+ if (!s)
+ return FALSE;
input_write_keyboard_event(s, flags, code);
- rdp_send_client_input_pdu(rdp, s);
+ return rdp_send_client_input_pdu(rdp, s);
}
-void input_write_unicode_keyboard_event(wStream* s, UINT16 flags, UINT16 code)
+static void input_write_unicode_keyboard_event(wStream* s, UINT16 flags, UINT16 code)
{
Stream_Write_UINT16(s, flags); /* keyboardFlags (2 bytes) */
Stream_Write_UINT16(s, code); /* unicodeCode (2 bytes) */
Stream_Write_UINT16(s, 0); /* pad2Octets (2 bytes) */
}
-void input_send_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL input_send_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
wStream* s;
UINT16 keyboardFlags = 0;
keyboardFlags |= (flags & KBD_FLAGS_RELEASE) ? KBD_FLAGS_RELEASE : 0;
s = rdp_client_input_pdu_init(rdp, INPUT_EVENT_UNICODE);
+ if (!s)
+ return FALSE;
input_write_unicode_keyboard_event(s, flags, code);
- rdp_send_client_input_pdu(rdp, s);
+ return rdp_send_client_input_pdu(rdp, s);
}
void input_write_mouse_event(wStream* s, UINT16 flags, UINT16 x, UINT16 y)
Stream_Write_UINT16(s, y); /* yPos (2 bytes) */
}
-void input_send_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL input_send_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
wStream* s;
rdpRdp* rdp = input->context->rdp;
s = rdp_client_input_pdu_init(rdp, INPUT_EVENT_MOUSE);
+ if (!s)
+ return FALSE;
input_write_mouse_event(s, flags, x, y);
- rdp_send_client_input_pdu(rdp, s);
+ return rdp_send_client_input_pdu(rdp, s);
}
-void input_write_extended_mouse_event(wStream* s, UINT16 flags, UINT16 x, UINT16 y)
+static void input_write_extended_mouse_event(wStream* s, UINT16 flags, UINT16 x, UINT16 y)
{
Stream_Write_UINT16(s, flags); /* pointerFlags (2 bytes) */
Stream_Write_UINT16(s, x); /* xPos (2 bytes) */
Stream_Write_UINT16(s, y); /* yPos (2 bytes) */
}
-void input_send_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL input_send_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
wStream* s;
rdpRdp* rdp = input->context->rdp;
s = rdp_client_input_pdu_init(rdp, INPUT_EVENT_MOUSEX);
+ if (!s)
+ return FALSE;
input_write_extended_mouse_event(s, flags, x, y);
- rdp_send_client_input_pdu(rdp, s);
+ return rdp_send_client_input_pdu(rdp, s);
}
-void input_send_focus_in_event(rdpInput* input, UINT16 toggleStates)
+BOOL input_send_focus_in_event(rdpInput* input, UINT16 toggleStates)
{
/* send a tab up like mstsc.exe */
- input_send_keyboard_event(input, KBD_FLAGS_RELEASE, 0x0f);
+ if (!input_send_keyboard_event(input, KBD_FLAGS_RELEASE, 0x0f))
+ return FALSE;
/* send the toggle key states */
- input_send_synchronize_event(input, (toggleStates & 0x1F));
+ if (!input_send_synchronize_event(input, (toggleStates & 0x1F)))
+ return FALSE;
/* send another tab up like mstsc.exe */
- input_send_keyboard_event(input, KBD_FLAGS_RELEASE, 0x0f);
+ return input_send_keyboard_event(input, KBD_FLAGS_RELEASE, 0x0f);
}
-static void input_send_keyboard_pause_event(rdpInput* input)
+BOOL input_send_keyboard_pause_event(rdpInput* input)
{
/* In ancient days, pause-down without control sent E1 1D 45 E1 9D C5,
* and pause-up sent nothing. However, reverse engineering mstsc shows
*/
/* Control down (0x1D) */
- input_send_keyboard_event(input, 0,
- RDP_SCANCODE_CODE(RDP_SCANCODE_LCONTROL));
+ if (!input_send_keyboard_event(input, 0,
+ RDP_SCANCODE_CODE(RDP_SCANCODE_LCONTROL)))
+ return FALSE;
+
/* Numlock down (0x45) */
- input_send_keyboard_event(input, 0,
- RDP_SCANCODE_CODE(RDP_SCANCODE_NUMLOCK));
+ if (!input_send_keyboard_event(input, 0,
+ RDP_SCANCODE_CODE(RDP_SCANCODE_NUMLOCK)))
+ return FALSE;
+
/* Control up (0x1D) */
- input_send_keyboard_event(input, KBD_FLAGS_RELEASE,
- RDP_SCANCODE_CODE(RDP_SCANCODE_LCONTROL));
+ if (!input_send_keyboard_event(input, KBD_FLAGS_RELEASE,
+ RDP_SCANCODE_CODE(RDP_SCANCODE_LCONTROL)))
+ return FALSE;
+
/* Numlock up (0x45) */
- input_send_keyboard_event(input, KBD_FLAGS_RELEASE,
+ return input_send_keyboard_event(input, KBD_FLAGS_RELEASE,
RDP_SCANCODE_CODE(RDP_SCANCODE_NUMLOCK));
}
-void input_send_fastpath_synchronize_event(rdpInput* input, UINT32 flags)
+BOOL input_send_fastpath_synchronize_event(rdpInput* input, UINT32 flags)
{
wStream* s;
rdpRdp* rdp = input->context->rdp;
/* The FastPath Synchronization eventFlags has identical values as SlowPath */
s = fastpath_input_pdu_init(rdp->fastpath, (BYTE) flags, FASTPATH_INPUT_EVENT_SYNC);
- fastpath_send_input_pdu(rdp->fastpath, s);
+ if (!s)
+ return FALSE;
+ return fastpath_send_input_pdu(rdp->fastpath, s);
}
-void input_send_fastpath_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL input_send_fastpath_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
wStream* s;
BYTE eventFlags = 0;
eventFlags |= (flags & KBD_FLAGS_RELEASE) ? FASTPATH_INPUT_KBDFLAGS_RELEASE : 0;
eventFlags |= (flags & KBD_FLAGS_EXTENDED) ? FASTPATH_INPUT_KBDFLAGS_EXTENDED : 0;
s = fastpath_input_pdu_init(rdp->fastpath, eventFlags, FASTPATH_INPUT_EVENT_SCANCODE);
+ if (!s)
+ return FALSE;
Stream_Write_UINT8(s, code); /* keyCode (1 byte) */
- fastpath_send_input_pdu(rdp->fastpath, s);
+ return fastpath_send_input_pdu(rdp->fastpath, s);
}
-void input_send_fastpath_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL input_send_fastpath_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
wStream* s;
BYTE eventFlags = 0;
eventFlags |= (flags & KBD_FLAGS_RELEASE) ? FASTPATH_INPUT_KBDFLAGS_RELEASE : 0;
s = fastpath_input_pdu_init(rdp->fastpath, eventFlags, FASTPATH_INPUT_EVENT_UNICODE);
+ if (!s)
+ return FALSE;
Stream_Write_UINT16(s, code); /* unicodeCode (2 bytes) */
- fastpath_send_input_pdu(rdp->fastpath, s);
+ return fastpath_send_input_pdu(rdp->fastpath, s);
}
-void input_send_fastpath_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL input_send_fastpath_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
wStream* s;
rdpRdp* rdp = input->context->rdp;
s = fastpath_input_pdu_init(rdp->fastpath, 0, FASTPATH_INPUT_EVENT_MOUSE);
+ if (!s)
+ return FALSE;
input_write_mouse_event(s, flags, x, y);
- fastpath_send_input_pdu(rdp->fastpath, s);
+ return fastpath_send_input_pdu(rdp->fastpath, s);
}
-void input_send_fastpath_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL input_send_fastpath_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
wStream* s;
rdpRdp* rdp = input->context->rdp;
s = fastpath_input_pdu_init(rdp->fastpath, 0, FASTPATH_INPUT_EVENT_MOUSEX);
+ if (!s)
+ return FALSE;
input_write_extended_mouse_event(s, flags, x, y);
- fastpath_send_input_pdu(rdp->fastpath, s);
+ return fastpath_send_input_pdu(rdp->fastpath, s);
}
-void input_send_fastpath_focus_in_event(rdpInput* input, UINT16 toggleStates)
+BOOL input_send_fastpath_focus_in_event(rdpInput* input, UINT16 toggleStates)
{
wStream* s;
rdpRdp* rdp = input->context->rdp;
BYTE eventFlags = 0;
s = fastpath_input_pdu_init_header(rdp->fastpath);
+ if (!s)
+ return FALSE;
/* send a tab up like mstsc.exe */
eventFlags = FASTPATH_INPUT_KBDFLAGS_RELEASE | FASTPATH_INPUT_EVENT_SCANCODE << 5;
Stream_Write_UINT8(s, eventFlags); /* Key Release event (1 byte) */
Stream_Write_UINT8(s, eventFlags); /* Key Release event (1 byte) */
Stream_Write_UINT8(s, 0x0f); /* keyCode (1 byte) */
- fastpath_send_multiple_input_pdu(rdp->fastpath, s, 3);
+ return fastpath_send_multiple_input_pdu(rdp->fastpath, s, 3);
}
-static void input_send_fastpath_keyboard_pause_event(rdpInput* input)
+BOOL input_send_fastpath_keyboard_pause_event(rdpInput* input)
{
/* In ancient days, pause-down without control sent E1 1D 45 E1 9D C5,
* and pause-up sent nothing. However, reverse engineering mstsc shows
| FASTPATH_INPUT_KBDFLAGS_RELEASE;
s = fastpath_input_pdu_init_header(rdp->fastpath);
+ if (!s)
+ return FALSE;
/* Control down (0x1D) */
Stream_Write_UINT8(s, keyDownEvent | FASTPATH_INPUT_KBDFLAGS_PREFIX_E1);
Stream_Write_UINT8(s, keyUpEvent);
Stream_Write_UINT8(s, RDP_SCANCODE_CODE(RDP_SCANCODE_NUMLOCK));
- fastpath_send_multiple_input_pdu(rdp->fastpath, s, 4);
+ return fastpath_send_multiple_input_pdu(rdp->fastpath, s, 4);
}
static BOOL input_recv_sync_event(rdpInput* input, wStream* s)
Stream_Seek(s, 2); /* pad2Octets (2 bytes) */
Stream_Read_UINT32(s, toggleFlags); /* toggleFlags (4 bytes) */
- IFCALL(input->SynchronizeEvent, input, toggleFlags);
-
- return TRUE;
+ IFCALLRETURN(TRUE, input->SynchronizeEvent, input, toggleFlags);
}
static BOOL input_recv_keyboard_event(rdpInput* input, wStream* s)
else
keyboardFlags |= KBD_FLAGS_DOWN;
- IFCALL(input->KeyboardEvent, input, keyboardFlags, keyCode);
-
- return TRUE;
+ IFCALLRETURN(TRUE, input->KeyboardEvent, input, keyboardFlags, keyCode);
}
static BOOL input_recv_unicode_keyboard_event(rdpInput* input, wStream* s)
else
keyboardFlags |= KBD_FLAGS_DOWN;
- IFCALL(input->UnicodeKeyboardEvent, input, keyboardFlags, unicodeCode);
-
- return TRUE;
+ IFCALLRETURN(TRUE, input->UnicodeKeyboardEvent, input, keyboardFlags, unicodeCode);
}
static BOOL input_recv_mouse_event(rdpInput* input, wStream* s)
Stream_Read_UINT16(s, xPos); /* xPos (2 bytes) */
Stream_Read_UINT16(s, yPos); /* yPos (2 bytes) */
- IFCALL(input->MouseEvent, input, pointerFlags, xPos, yPos);
-
- return TRUE;
+ IFCALLRETURN(TRUE, input->MouseEvent, input, pointerFlags, xPos, yPos);
}
static BOOL input_recv_extended_mouse_event(rdpInput* input, wStream* s)
Stream_Read_UINT16(s, xPos); /* xPos (2 bytes) */
Stream_Read_UINT16(s, yPos); /* yPos (2 bytes) */
- IFCALL(input->ExtendedMouseEvent, input, pointerFlags, xPos, yPos);
-
- return TRUE;
+ IFCALLRETURN(TRUE, input->ExtendedMouseEvent, input, pointerFlags, xPos, yPos);
}
static BOOL input_recv_event(rdpInput* input, wStream* s)
}
}
-void freerdp_input_send_synchronize_event(rdpInput* input, UINT32 flags)
+BOOL freerdp_input_send_synchronize_event(rdpInput* input, UINT32 flags)
{
- IFCALL(input->SynchronizeEvent, input, flags);
+ IFCALLRETURN(TRUE, input->SynchronizeEvent, input, flags);
}
-void freerdp_input_send_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL freerdp_input_send_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
- IFCALL(input->KeyboardEvent, input, flags, code);
+ IFCALLRETURN(TRUE, input->KeyboardEvent, input, flags, code);
}
-void freerdp_input_send_keyboard_event_ex(rdpInput* input, BOOL down, UINT32 rdp_scancode)
+BOOL freerdp_input_send_keyboard_event_ex(rdpInput* input, BOOL down, UINT32 rdp_scancode)
{
- freerdp_input_send_keyboard_event(input,
+ return freerdp_input_send_keyboard_event(input,
(RDP_SCANCODE_EXTENDED(rdp_scancode) ? KBD_FLAGS_EXTENDED : 0) |
((down) ? KBD_FLAGS_DOWN : KBD_FLAGS_RELEASE),
RDP_SCANCODE_CODE(rdp_scancode));
}
-void freerdp_input_send_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL freerdp_input_send_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
- IFCALL(input->UnicodeKeyboardEvent, input, flags, code);
+ IFCALLRETURN(TRUE, input->UnicodeKeyboardEvent, input, flags, code);
}
-void freerdp_input_send_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL freerdp_input_send_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
- IFCALL(input->MouseEvent, input, flags, x, y);
+ IFCALLRETURN(TRUE, input->MouseEvent, input, flags, x, y);
}
-void freerdp_input_send_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL freerdp_input_send_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
- IFCALL(input->ExtendedMouseEvent, input, flags, x, y);
+ IFCALLRETURN(TRUE, input->ExtendedMouseEvent, input, flags, x, y);
}
-void freerdp_input_send_focus_in_event(rdpInput* input, UINT16 toggleStates)
+BOOL freerdp_input_send_focus_in_event(rdpInput* input, UINT16 toggleStates)
{
- IFCALL(input->FocusInEvent, input, toggleStates);
+ IFCALLRETURN(TRUE, input->FocusInEvent, input, toggleStates);
}
-void freerdp_input_send_keyboard_pause_event(rdpInput* input)
+BOOL freerdp_input_send_keyboard_pause_event(rdpInput* input)
{
- IFCALL(input->KeyboardPauseEvent, input);
+ IFCALLRETURN(TRUE, input->KeyboardPauseEvent, input);
}
int input_process_events(rdpInput* input)
#define RDP_CLIENT_INPUT_PDU_HEADER_LENGTH 4
-void input_send_synchronize_event(rdpInput* input, UINT32 flags);
-void input_send_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
-void input_send_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
-void input_send_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
-void input_send_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
-
-void input_send_fastpath_synchronize_event(rdpInput* input, UINT32 flags);
-void input_send_fastpath_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
-void input_send_fastpath_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
-void input_send_fastpath_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
-void input_send_fastpath_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+BOOL input_send_synchronize_event(rdpInput* input, UINT32 flags);
+BOOL input_send_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL input_send_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL input_send_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+BOOL input_send_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+
+BOOL input_send_fastpath_synchronize_event(rdpInput* input, UINT32 flags);
+BOOL input_send_fastpath_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL input_send_fastpath_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code);
+BOOL input_send_fastpath_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
+BOOL input_send_fastpath_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y);
BOOL input_recv(rdpInput* input, wStream* s);
/* Update */
-static void update_message_BeginPaint(rdpContext* context)
+static BOOL update_message_BeginPaint(rdpContext* context)
{
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, BeginPaint), NULL, NULL);
+
+ return TRUE;
}
-static void update_message_EndPaint(rdpContext* context)
+static BOOL update_message_EndPaint(rdpContext* context)
{
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, EndPaint), NULL, NULL);
+ return TRUE;
}
-static void update_message_SetBounds(rdpContext* context, rdpBounds* bounds)
+static BOOL update_message_SetBounds(rdpContext* context, rdpBounds* bounds)
{
rdpBounds* wParam = NULL;
if (bounds)
{
wParam = (rdpBounds*) malloc(sizeof(rdpBounds));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, bounds, sizeof(rdpBounds));
}
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, SetBounds), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_Synchronize(rdpContext* context)
+static BOOL update_message_Synchronize(rdpContext* context)
{
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, Synchronize), NULL, NULL);
+ return TRUE;
}
-static void update_message_DesktopResize(rdpContext* context)
+static BOOL update_message_DesktopResize(rdpContext* context)
{
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, DesktopResize), NULL, NULL);
+ return TRUE;
}
-static void update_message_BitmapUpdate(rdpContext* context, BITMAP_UPDATE* bitmap)
+static BOOL update_message_BitmapUpdate(rdpContext* context, BITMAP_UPDATE* bitmap)
{
UINT32 index;
BITMAP_UPDATE* wParam;
wParam = (BITMAP_UPDATE*) malloc(sizeof(BITMAP_UPDATE));
+ if (!wParam)
+ return FALSE;
wParam->number = bitmap->number;
wParam->count = wParam->number;
wParam->rectangles = (BITMAP_DATA*) malloc(sizeof(BITMAP_DATA) * wParam->number);
+ if (!wParam->rectangles)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->rectangles, bitmap->rectangles, sizeof(BITMAP_DATA) * wParam->number);
for (index = 0; index < wParam->number; index++)
StreamPool_AddRef(context->rdp->transport->ReceivePool, bitmap->rectangles[index].bitmapDataStream);
#else
wParam->rectangles[index].bitmapDataStream = (BYTE*) malloc(wParam->rectangles[index].bitmapLength);
+ if (!wParam->rectangles[index].bitmapDataStream)
+ {
+ for (index -= 1; index >= 0; --index)
+ {
+ free(wParam->rectangles[index].bitmapDataStream);
+ }
+ free(wParam->rectangles);
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->rectangles[index].bitmapDataStream, bitmap->rectangles[index].bitmapDataStream,
wParam->rectangles[index].bitmapLength);
#endif
}
-
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, BitmapUpdate), (void*) wParam, NULL);
+
+ return TRUE;
}
-static void update_message_Palette(rdpContext* context, PALETTE_UPDATE* palette)
+static BOOL update_message_Palette(rdpContext* context, PALETTE_UPDATE* palette)
{
PALETTE_UPDATE* wParam;
wParam = (PALETTE_UPDATE*) malloc(sizeof(PALETTE_UPDATE));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, palette, sizeof(PALETTE_UPDATE));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, Palette), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_PlaySound(rdpContext* context, PLAY_SOUND_UPDATE* playSound)
+static BOOL update_message_PlaySound(rdpContext* context, PLAY_SOUND_UPDATE* playSound)
{
PLAY_SOUND_UPDATE* wParam;
wParam = (PLAY_SOUND_UPDATE*) malloc(sizeof(PLAY_SOUND_UPDATE));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, playSound, sizeof(PLAY_SOUND_UPDATE));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, PlaySound), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_SetKeyboardIndicators(rdpContext* context, UINT16 led_flags)
+static BOOL update_message_SetKeyboardIndicators(rdpContext* context, UINT16 led_flags)
{
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, SetKeyboardIndicators), (void*)(size_t)led_flags, NULL);
+ return TRUE;
}
-static void update_message_RefreshRect(rdpContext* context, BYTE count, RECTANGLE_16* areas)
+static BOOL update_message_RefreshRect(rdpContext* context, BYTE count, RECTANGLE_16* areas)
{
RECTANGLE_16* lParam;
lParam = (RECTANGLE_16*) malloc(sizeof(RECTANGLE_16) * count);
+ if (!lParam)
+ return FALSE;
CopyMemory(lParam, areas, sizeof(RECTANGLE_16) * count);
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, RefreshRect), (void*) (size_t) count, (void*) lParam);
+ return TRUE;
}
-static void update_message_SuppressOutput(rdpContext* context, BYTE allow, RECTANGLE_16* area)
+static BOOL update_message_SuppressOutput(rdpContext* context, BYTE allow, RECTANGLE_16* area)
{
RECTANGLE_16* lParam = NULL;
if (area)
{
lParam = (RECTANGLE_16*) malloc(sizeof(RECTANGLE_16));
+ if (!lParam)
+ return FALSE;
CopyMemory(lParam, area, sizeof(RECTANGLE_16));
}
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, SuppressOutput), (void*) (size_t) allow, (void*) lParam);
+ return TRUE;
}
-static void update_message_SurfaceCommand(rdpContext* context, wStream* s)
+static BOOL update_message_SurfaceCommand(rdpContext* context, wStream* s)
{
wStream* wParam;
wParam = (wStream*) malloc(sizeof(wStream));
+ if (!wParam)
+ return FALSE;
wParam->capacity = Stream_Capacity(s);
wParam->buffer = (BYTE*) malloc(wParam->capacity);
+ if (!wParam->buffer)
+ {
+ free(wParam);
+ return FALSE;
+ }
+
wParam->pointer = wParam->buffer;
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, SurfaceCommand), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_SurfaceBits(rdpContext* context, SURFACE_BITS_COMMAND* surfaceBitsCommand)
+static BOOL update_message_SurfaceBits(rdpContext* context, SURFACE_BITS_COMMAND* surfaceBitsCommand)
{
SURFACE_BITS_COMMAND* wParam;
wParam = (SURFACE_BITS_COMMAND*) malloc(sizeof(SURFACE_BITS_COMMAND));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, surfaceBitsCommand, sizeof(SURFACE_BITS_COMMAND));
#ifdef WITH_STREAM_POOL
StreamPool_AddRef(context->rdp->transport->ReceivePool, surfaceBitsCommand->bitmapData);
#else
wParam->bitmapData = (BYTE*) malloc(wParam->bitmapDataLength);
+ if (!wParam->bitmapData)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->bitmapData, surfaceBitsCommand->bitmapData, wParam->bitmapDataLength);
#endif
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, SurfaceBits), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_SurfaceFrameMarker(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker)
+static BOOL update_message_SurfaceFrameMarker(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker)
{
SURFACE_FRAME_MARKER* wParam;
wParam = (SURFACE_FRAME_MARKER*) malloc(sizeof(SURFACE_FRAME_MARKER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, surfaceFrameMarker, sizeof(SURFACE_FRAME_MARKER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, SurfaceFrameMarker), (void*) wParam, NULL);
+
+ return TRUE;
}
-static void update_message_SurfaceFrameAcknowledge(rdpContext* context, UINT32 frameId)
+static BOOL update_message_SurfaceFrameAcknowledge(rdpContext* context, UINT32 frameId)
{
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(Update, SurfaceFrameAcknowledge), (void*) (size_t) frameId, NULL);
+
+ return TRUE;
}
/* Primary Update */
-static void update_message_DstBlt(rdpContext* context, DSTBLT_ORDER* dstBlt)
+static BOOL update_message_DstBlt(rdpContext* context, DSTBLT_ORDER* dstBlt)
{
DSTBLT_ORDER* wParam;
wParam = (DSTBLT_ORDER*) malloc(sizeof(DSTBLT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, dstBlt, sizeof(DSTBLT_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, DstBlt), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_PatBlt(rdpContext* context, PATBLT_ORDER* patBlt)
+static BOOL update_message_PatBlt(rdpContext* context, PATBLT_ORDER* patBlt)
{
PATBLT_ORDER* wParam;
wParam = (PATBLT_ORDER*) malloc(sizeof(PATBLT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, patBlt, sizeof(PATBLT_ORDER));
wParam->brush.data = (BYTE*) wParam->brush.p8x8;
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, PatBlt), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_ScrBlt(rdpContext* context, SCRBLT_ORDER* scrBlt)
+static BOOL update_message_ScrBlt(rdpContext* context, SCRBLT_ORDER* scrBlt)
{
SCRBLT_ORDER* wParam;
wParam = (SCRBLT_ORDER*) malloc(sizeof(SCRBLT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, scrBlt, sizeof(SCRBLT_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, ScrBlt), (void*) wParam, NULL);
+
+ return TRUE;
}
-static void update_message_OpaqueRect(rdpContext* context, OPAQUE_RECT_ORDER* opaqueRect)
+static BOOL update_message_OpaqueRect(rdpContext* context, OPAQUE_RECT_ORDER* opaqueRect)
{
OPAQUE_RECT_ORDER* wParam;
wParam = (OPAQUE_RECT_ORDER*) malloc(sizeof(OPAQUE_RECT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, opaqueRect, sizeof(OPAQUE_RECT_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, OpaqueRect), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_DrawNineGrid(rdpContext* context, DRAW_NINE_GRID_ORDER* drawNineGrid)
+static BOOL update_message_DrawNineGrid(rdpContext* context, DRAW_NINE_GRID_ORDER* drawNineGrid)
{
DRAW_NINE_GRID_ORDER* wParam;
wParam = (DRAW_NINE_GRID_ORDER*) malloc(sizeof(DRAW_NINE_GRID_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, drawNineGrid, sizeof(DRAW_NINE_GRID_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, DrawNineGrid), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_MultiDstBlt(rdpContext* context, MULTI_DSTBLT_ORDER* multiDstBlt)
+static BOOL update_message_MultiDstBlt(rdpContext* context, MULTI_DSTBLT_ORDER* multiDstBlt)
{
MULTI_DSTBLT_ORDER* wParam;
wParam = (MULTI_DSTBLT_ORDER*) malloc(sizeof(MULTI_DSTBLT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, multiDstBlt, sizeof(MULTI_DSTBLT_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, MultiDstBlt), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_MultiPatBlt(rdpContext* context, MULTI_PATBLT_ORDER* multiPatBlt)
+static BOOL update_message_MultiPatBlt(rdpContext* context, MULTI_PATBLT_ORDER* multiPatBlt)
{
MULTI_PATBLT_ORDER* wParam;
wParam = (MULTI_PATBLT_ORDER*) malloc(sizeof(MULTI_PATBLT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, multiPatBlt, sizeof(MULTI_PATBLT_ORDER));
wParam->brush.data = (BYTE*) wParam->brush.p8x8;
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, MultiPatBlt), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_MultiScrBlt(rdpContext* context, MULTI_SCRBLT_ORDER* multiScrBlt)
+static BOOL update_message_MultiScrBlt(rdpContext* context, MULTI_SCRBLT_ORDER* multiScrBlt)
{
MULTI_SCRBLT_ORDER* wParam;
wParam = (MULTI_SCRBLT_ORDER*) malloc(sizeof(MULTI_SCRBLT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, multiScrBlt, sizeof(MULTI_SCRBLT_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, MultiScrBlt), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_MultiOpaqueRect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multiOpaqueRect)
+static BOOL update_message_MultiOpaqueRect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multiOpaqueRect)
{
MULTI_OPAQUE_RECT_ORDER* wParam;
wParam = (MULTI_OPAQUE_RECT_ORDER*) malloc(sizeof(MULTI_OPAQUE_RECT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, multiOpaqueRect, sizeof(MULTI_OPAQUE_RECT_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, MultiOpaqueRect), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_MultiDrawNineGrid(rdpContext* context, MULTI_DRAW_NINE_GRID_ORDER* multiDrawNineGrid)
+static BOOL update_message_MultiDrawNineGrid(rdpContext* context, MULTI_DRAW_NINE_GRID_ORDER* multiDrawNineGrid)
{
MULTI_DRAW_NINE_GRID_ORDER* wParam;
wParam = (MULTI_DRAW_NINE_GRID_ORDER*) malloc(sizeof(MULTI_DRAW_NINE_GRID_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, multiDrawNineGrid, sizeof(MULTI_DRAW_NINE_GRID_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, MultiDrawNineGrid), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_LineTo(rdpContext* context, LINE_TO_ORDER* lineTo)
+static BOOL update_message_LineTo(rdpContext* context, LINE_TO_ORDER* lineTo)
{
LINE_TO_ORDER* wParam;
wParam = (LINE_TO_ORDER*) malloc(sizeof(LINE_TO_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, lineTo, sizeof(LINE_TO_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, LineTo), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_Polyline(rdpContext* context, POLYLINE_ORDER* polyline)
+static BOOL update_message_Polyline(rdpContext* context, POLYLINE_ORDER* polyline)
{
POLYLINE_ORDER* wParam;
wParam = (POLYLINE_ORDER*) malloc(sizeof(POLYLINE_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, polyline, sizeof(POLYLINE_ORDER));
wParam->points = (DELTA_POINT*) malloc(sizeof(DELTA_POINT) * wParam->numDeltaEntries);
+ if (!wParam->points)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->points, polyline->points, sizeof(DELTA_POINT) * wParam->numDeltaEntries);
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, Polyline), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_MemBlt(rdpContext* context, MEMBLT_ORDER* memBlt)
+static BOOL update_message_MemBlt(rdpContext* context, MEMBLT_ORDER* memBlt)
{
MEMBLT_ORDER* wParam;
wParam = (MEMBLT_ORDER*) malloc(sizeof(MEMBLT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, memBlt, sizeof(MEMBLT_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, MemBlt), (void*) wParam, NULL);
+
+ return TRUE;
}
-static void update_message_Mem3Blt(rdpContext* context, MEM3BLT_ORDER* mem3Blt)
+static BOOL update_message_Mem3Blt(rdpContext* context, MEM3BLT_ORDER* mem3Blt)
{
MEM3BLT_ORDER* wParam;
wParam = (MEM3BLT_ORDER*) malloc(sizeof(MEM3BLT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, mem3Blt, sizeof(MEM3BLT_ORDER));
wParam->brush.data = (BYTE*) wParam->brush.p8x8;
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, Mem3Blt), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_SaveBitmap(rdpContext* context, SAVE_BITMAP_ORDER* saveBitmap)
+static BOOL update_message_SaveBitmap(rdpContext* context, SAVE_BITMAP_ORDER* saveBitmap)
{
SAVE_BITMAP_ORDER* wParam;
wParam = (SAVE_BITMAP_ORDER*) malloc(sizeof(SAVE_BITMAP_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, saveBitmap, sizeof(SAVE_BITMAP_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, SaveBitmap), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_GlyphIndex(rdpContext* context, GLYPH_INDEX_ORDER* glyphIndex)
+static BOOL update_message_GlyphIndex(rdpContext* context, GLYPH_INDEX_ORDER* glyphIndex)
{
GLYPH_INDEX_ORDER* wParam;
wParam = (GLYPH_INDEX_ORDER*) malloc(sizeof(GLYPH_INDEX_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, glyphIndex, sizeof(GLYPH_INDEX_ORDER));
wParam->brush.data = (BYTE*) wParam->brush.p8x8;
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, GlyphIndex), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_FastIndex(rdpContext* context, FAST_INDEX_ORDER* fastIndex)
+static BOOL update_message_FastIndex(rdpContext* context, FAST_INDEX_ORDER* fastIndex)
{
FAST_INDEX_ORDER* wParam;
wParam = (FAST_INDEX_ORDER*) malloc(sizeof(FAST_INDEX_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, fastIndex, sizeof(FAST_INDEX_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, FastIndex), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_FastGlyph(rdpContext* context, FAST_GLYPH_ORDER* fastGlyph)
+static BOOL update_message_FastGlyph(rdpContext* context, FAST_GLYPH_ORDER* fastGlyph)
{
FAST_GLYPH_ORDER* wParam;
wParam = (FAST_GLYPH_ORDER*) malloc(sizeof(FAST_GLYPH_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, fastGlyph, sizeof(FAST_GLYPH_ORDER));
if (wParam->cbData > 1)
{
wParam->glyphData.aj = (BYTE*) malloc(fastGlyph->glyphData.cb);
+ if (!wParam->glyphData.aj)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->glyphData.aj, fastGlyph->glyphData.aj, fastGlyph->glyphData.cb);
}
else
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, FastGlyph), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_PolygonSC(rdpContext* context, POLYGON_SC_ORDER* polygonSC)
+static BOOL update_message_PolygonSC(rdpContext* context, POLYGON_SC_ORDER* polygonSC)
{
POLYGON_SC_ORDER* wParam;
wParam = (POLYGON_SC_ORDER*) malloc(sizeof(POLYGON_SC_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, polygonSC, sizeof(POLYGON_SC_ORDER));
wParam->points = (DELTA_POINT*) malloc(sizeof(DELTA_POINT) * wParam->numPoints);
+ if (!wParam->points)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->points, polygonSC, sizeof(DELTA_POINT) * wParam->numPoints);
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, PolygonSC), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_PolygonCB(rdpContext* context, POLYGON_CB_ORDER* polygonCB)
+static BOOL update_message_PolygonCB(rdpContext* context, POLYGON_CB_ORDER* polygonCB)
{
POLYGON_CB_ORDER* wParam;
wParam = (POLYGON_CB_ORDER*) malloc(sizeof(POLYGON_CB_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, polygonCB, sizeof(POLYGON_CB_ORDER));
wParam->points = (DELTA_POINT*) malloc(sizeof(DELTA_POINT) * wParam->numPoints);
+ if (!wParam->points)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->points, polygonCB, sizeof(DELTA_POINT) * wParam->numPoints);
wParam->brush.data = (BYTE*) wParam->brush.p8x8;
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, PolygonCB), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_EllipseSC(rdpContext* context, ELLIPSE_SC_ORDER* ellipseSC)
+static BOOL update_message_EllipseSC(rdpContext* context, ELLIPSE_SC_ORDER* ellipseSC)
{
ELLIPSE_SC_ORDER* wParam;
wParam = (ELLIPSE_SC_ORDER*) malloc(sizeof(ELLIPSE_SC_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, ellipseSC, sizeof(ELLIPSE_SC_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, EllipseSC), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_EllipseCB(rdpContext* context, ELLIPSE_CB_ORDER* ellipseCB)
+static BOOL update_message_EllipseCB(rdpContext* context, ELLIPSE_CB_ORDER* ellipseCB)
{
ELLIPSE_CB_ORDER* wParam;
wParam = (ELLIPSE_CB_ORDER*) malloc(sizeof(ELLIPSE_CB_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, ellipseCB, sizeof(ELLIPSE_CB_ORDER));
wParam->brush.data = (BYTE*) wParam->brush.p8x8;
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PrimaryUpdate, EllipseCB), (void*) wParam, NULL);
+ return TRUE;
}
/* Secondary Update */
-static void update_message_CacheBitmap(rdpContext* context, CACHE_BITMAP_ORDER* cacheBitmapOrder)
+static BOOL update_message_CacheBitmap(rdpContext* context, CACHE_BITMAP_ORDER* cacheBitmapOrder)
{
CACHE_BITMAP_ORDER* wParam;
wParam = (CACHE_BITMAP_ORDER*) malloc(sizeof(CACHE_BITMAP_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, cacheBitmapOrder, sizeof(CACHE_BITMAP_ORDER));
wParam->bitmapDataStream = (BYTE*) malloc(wParam->bitmapLength);
+ if (!wParam->bitmapDataStream)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->bitmapDataStream, cacheBitmapOrder, wParam->bitmapLength);
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(SecondaryUpdate, CacheBitmap), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_CacheBitmapV2(rdpContext* context, CACHE_BITMAP_V2_ORDER* cacheBitmapV2Order)
+static BOOL update_message_CacheBitmapV2(rdpContext* context, CACHE_BITMAP_V2_ORDER* cacheBitmapV2Order)
{
CACHE_BITMAP_V2_ORDER* wParam;
wParam = (CACHE_BITMAP_V2_ORDER*) malloc(sizeof(CACHE_BITMAP_V2_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, cacheBitmapV2Order, sizeof(CACHE_BITMAP_V2_ORDER));
wParam->bitmapDataStream = (BYTE*) malloc(wParam->bitmapLength);
+ if (!wParam->bitmapDataStream)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->bitmapDataStream, cacheBitmapV2Order->bitmapDataStream, wParam->bitmapLength);
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(SecondaryUpdate, CacheBitmapV2), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_CacheBitmapV3(rdpContext* context, CACHE_BITMAP_V3_ORDER* cacheBitmapV3Order)
+static BOOL update_message_CacheBitmapV3(rdpContext* context, CACHE_BITMAP_V3_ORDER* cacheBitmapV3Order)
{
CACHE_BITMAP_V3_ORDER* wParam;
wParam = (CACHE_BITMAP_V3_ORDER*) malloc(sizeof(CACHE_BITMAP_V3_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, cacheBitmapV3Order, sizeof(CACHE_BITMAP_V3_ORDER));
wParam->bitmapData.data = (BYTE*) malloc(wParam->bitmapData.length);
+ if (!wParam->bitmapData.data)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->bitmapData.data, cacheBitmapV3Order->bitmapData.data, wParam->bitmapData.length);
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(SecondaryUpdate, CacheBitmapV3), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_CacheColorTable(rdpContext* context, CACHE_COLOR_TABLE_ORDER* cacheColorTableOrder)
+static BOOL update_message_CacheColorTable(rdpContext* context, CACHE_COLOR_TABLE_ORDER* cacheColorTableOrder)
{
CACHE_COLOR_TABLE_ORDER* wParam;
wParam = (CACHE_COLOR_TABLE_ORDER*) malloc(sizeof(CACHE_COLOR_TABLE_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, cacheColorTableOrder, sizeof(CACHE_COLOR_TABLE_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(SecondaryUpdate, CacheColorTable), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_CacheGlyph(rdpContext* context, CACHE_GLYPH_ORDER* cacheGlyphOrder)
+static BOOL update_message_CacheGlyph(rdpContext* context, CACHE_GLYPH_ORDER* cacheGlyphOrder)
{
CACHE_GLYPH_ORDER* wParam;
wParam = (CACHE_GLYPH_ORDER*) malloc(sizeof(CACHE_GLYPH_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, cacheGlyphOrder, sizeof(CACHE_GLYPH_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(SecondaryUpdate, CacheGlyph), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_CacheGlyphV2(rdpContext* context, CACHE_GLYPH_V2_ORDER* cacheGlyphV2Order)
+static BOOL update_message_CacheGlyphV2(rdpContext* context, CACHE_GLYPH_V2_ORDER* cacheGlyphV2Order)
{
CACHE_GLYPH_V2_ORDER* wParam;
wParam = (CACHE_GLYPH_V2_ORDER*) malloc(sizeof(CACHE_GLYPH_V2_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, cacheGlyphV2Order, sizeof(CACHE_GLYPH_V2_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(SecondaryUpdate, CacheGlyphV2), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_CacheBrush(rdpContext* context, CACHE_BRUSH_ORDER* cacheBrushOrder)
+static BOOL update_message_CacheBrush(rdpContext* context, CACHE_BRUSH_ORDER* cacheBrushOrder)
{
CACHE_BRUSH_ORDER* wParam;
wParam = (CACHE_BRUSH_ORDER*) malloc(sizeof(CACHE_BRUSH_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, cacheBrushOrder, sizeof(CACHE_BRUSH_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(SecondaryUpdate, CacheBrush), (void*) wParam, NULL);
+ return TRUE;
}
/* Alternate Secondary Update */
-static void update_message_CreateOffscreenBitmap(rdpContext* context, CREATE_OFFSCREEN_BITMAP_ORDER* createOffscreenBitmap)
+static BOOL update_message_CreateOffscreenBitmap(rdpContext* context, CREATE_OFFSCREEN_BITMAP_ORDER* createOffscreenBitmap)
{
CREATE_OFFSCREEN_BITMAP_ORDER* wParam;
wParam = (CREATE_OFFSCREEN_BITMAP_ORDER*) malloc(sizeof(CREATE_OFFSCREEN_BITMAP_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, createOffscreenBitmap, sizeof(CREATE_OFFSCREEN_BITMAP_ORDER));
wParam->deleteList.cIndices = createOffscreenBitmap->deleteList.cIndices;
wParam->deleteList.sIndices = wParam->deleteList.cIndices;
wParam->deleteList.indices = (UINT16*) malloc(sizeof(UINT16) * wParam->deleteList.cIndices);
+ if (!wParam->deleteList.indices)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(wParam->deleteList.indices, createOffscreenBitmap->deleteList.indices, wParam->deleteList.cIndices);
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, CreateOffscreenBitmap), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_SwitchSurface(rdpContext* context, SWITCH_SURFACE_ORDER* switchSurface)
+static BOOL update_message_SwitchSurface(rdpContext* context, SWITCH_SURFACE_ORDER* switchSurface)
{
SWITCH_SURFACE_ORDER* wParam;
wParam = (SWITCH_SURFACE_ORDER*) malloc(sizeof(SWITCH_SURFACE_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, switchSurface, sizeof(SWITCH_SURFACE_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, SwitchSurface), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_CreateNineGridBitmap(rdpContext* context, CREATE_NINE_GRID_BITMAP_ORDER* createNineGridBitmap)
+static BOOL update_message_CreateNineGridBitmap(rdpContext* context, CREATE_NINE_GRID_BITMAP_ORDER* createNineGridBitmap)
{
CREATE_NINE_GRID_BITMAP_ORDER* wParam;
wParam = (CREATE_NINE_GRID_BITMAP_ORDER*) malloc(sizeof(CREATE_NINE_GRID_BITMAP_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, createNineGridBitmap, sizeof(CREATE_NINE_GRID_BITMAP_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, CreateNineGridBitmap), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_FrameMarker(rdpContext* context, FRAME_MARKER_ORDER* frameMarker)
+static BOOL update_message_FrameMarker(rdpContext* context, FRAME_MARKER_ORDER* frameMarker)
{
FRAME_MARKER_ORDER* wParam;
wParam = (FRAME_MARKER_ORDER*) malloc(sizeof(FRAME_MARKER_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, frameMarker, sizeof(FRAME_MARKER_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, FrameMarker), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_StreamBitmapFirst(rdpContext* context, STREAM_BITMAP_FIRST_ORDER* streamBitmapFirst)
+static BOOL update_message_StreamBitmapFirst(rdpContext* context, STREAM_BITMAP_FIRST_ORDER* streamBitmapFirst)
{
STREAM_BITMAP_FIRST_ORDER* wParam;
wParam = (STREAM_BITMAP_FIRST_ORDER*) malloc(sizeof(STREAM_BITMAP_FIRST_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, streamBitmapFirst, sizeof(STREAM_BITMAP_FIRST_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, StreamBitmapFirst), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_StreamBitmapNext(rdpContext* context, STREAM_BITMAP_NEXT_ORDER* streamBitmapNext)
+static BOOL update_message_StreamBitmapNext(rdpContext* context, STREAM_BITMAP_NEXT_ORDER* streamBitmapNext)
{
STREAM_BITMAP_NEXT_ORDER* wParam;
wParam = (STREAM_BITMAP_NEXT_ORDER*) malloc(sizeof(STREAM_BITMAP_NEXT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, streamBitmapNext, sizeof(STREAM_BITMAP_NEXT_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, StreamBitmapNext), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_DrawGdiPlusFirst(rdpContext* context, DRAW_GDIPLUS_FIRST_ORDER* drawGdiPlusFirst)
+static BOOL update_message_DrawGdiPlusFirst(rdpContext* context, DRAW_GDIPLUS_FIRST_ORDER* drawGdiPlusFirst)
{
DRAW_GDIPLUS_FIRST_ORDER* wParam;
wParam = (DRAW_GDIPLUS_FIRST_ORDER*) malloc(sizeof(DRAW_GDIPLUS_FIRST_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, drawGdiPlusFirst, sizeof(DRAW_GDIPLUS_FIRST_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, DrawGdiPlusFirst), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_DrawGdiPlusNext(rdpContext* context, DRAW_GDIPLUS_NEXT_ORDER* drawGdiPlusNext)
+static BOOL update_message_DrawGdiPlusNext(rdpContext* context, DRAW_GDIPLUS_NEXT_ORDER* drawGdiPlusNext)
{
DRAW_GDIPLUS_NEXT_ORDER* wParam;
wParam = (DRAW_GDIPLUS_NEXT_ORDER*) malloc(sizeof(DRAW_GDIPLUS_NEXT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, drawGdiPlusNext, sizeof(DRAW_GDIPLUS_NEXT_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, DrawGdiPlusNext), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_DrawGdiPlusEnd(rdpContext* context, DRAW_GDIPLUS_END_ORDER* drawGdiPlusEnd)
+static BOOL update_message_DrawGdiPlusEnd(rdpContext* context, DRAW_GDIPLUS_END_ORDER* drawGdiPlusEnd)
{
DRAW_GDIPLUS_END_ORDER* wParam;
wParam = (DRAW_GDIPLUS_END_ORDER*) malloc(sizeof(DRAW_GDIPLUS_END_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, drawGdiPlusEnd, sizeof(DRAW_GDIPLUS_END_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, DrawGdiPlusEnd), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_DrawGdiPlusCacheFirst(rdpContext* context, DRAW_GDIPLUS_CACHE_FIRST_ORDER* drawGdiPlusCacheFirst)
+static BOOL update_message_DrawGdiPlusCacheFirst(rdpContext* context, DRAW_GDIPLUS_CACHE_FIRST_ORDER* drawGdiPlusCacheFirst)
{
DRAW_GDIPLUS_CACHE_FIRST_ORDER* wParam;
wParam = (DRAW_GDIPLUS_CACHE_FIRST_ORDER*) malloc(sizeof(DRAW_GDIPLUS_CACHE_FIRST_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, drawGdiPlusCacheFirst, sizeof(DRAW_GDIPLUS_CACHE_FIRST_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, DrawGdiPlusCacheFirst), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_DrawGdiPlusCacheNext(rdpContext* context, DRAW_GDIPLUS_CACHE_NEXT_ORDER* drawGdiPlusCacheNext)
+static BOOL update_message_DrawGdiPlusCacheNext(rdpContext* context, DRAW_GDIPLUS_CACHE_NEXT_ORDER* drawGdiPlusCacheNext)
{
DRAW_GDIPLUS_CACHE_NEXT_ORDER* wParam;
wParam = (DRAW_GDIPLUS_CACHE_NEXT_ORDER*) malloc(sizeof(DRAW_GDIPLUS_CACHE_NEXT_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, drawGdiPlusCacheNext, sizeof(DRAW_GDIPLUS_CACHE_NEXT_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, DrawGdiPlusCacheNext), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_DrawGdiPlusCacheEnd(rdpContext* context, DRAW_GDIPLUS_CACHE_END_ORDER* drawGdiPlusCacheEnd)
+static BOOL update_message_DrawGdiPlusCacheEnd(rdpContext* context, DRAW_GDIPLUS_CACHE_END_ORDER* drawGdiPlusCacheEnd)
{
DRAW_GDIPLUS_CACHE_END_ORDER* wParam;
wParam = (DRAW_GDIPLUS_CACHE_END_ORDER*) malloc(sizeof(DRAW_GDIPLUS_CACHE_END_ORDER));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, drawGdiPlusCacheEnd, sizeof(DRAW_GDIPLUS_CACHE_END_ORDER));
/* TODO: complete copy */
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(AltSecUpdate, DrawGdiPlusCacheEnd), (void*) wParam, NULL);
+ return TRUE;
}
/* Window Update */
-static void update_message_WindowCreate(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* windowState)
+static BOOL update_message_WindowCreate(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* windowState)
{
WINDOW_ORDER_INFO* wParam;
WINDOW_STATE_ORDER* lParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
lParam = (WINDOW_STATE_ORDER*) malloc(sizeof(WINDOW_STATE_ORDER));
+ if (!lParam)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(lParam, windowState, sizeof(WINDOW_STATE_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, WindowCreate), (void*) wParam, (void*) lParam);
+ return TRUE;
}
-static void update_message_WindowUpdate(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* windowState)
+static BOOL update_message_WindowUpdate(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_STATE_ORDER* windowState)
{
WINDOW_ORDER_INFO* wParam;
WINDOW_STATE_ORDER* lParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
lParam = (WINDOW_STATE_ORDER*) malloc(sizeof(WINDOW_STATE_ORDER));
+ if (!lParam)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(lParam, windowState, sizeof(WINDOW_STATE_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, WindowUpdate), (void*) wParam, (void*) lParam);
+ return TRUE;
}
-static void update_message_WindowIcon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* windowIcon)
+static BOOL update_message_WindowIcon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* windowIcon)
{
WINDOW_ORDER_INFO* wParam;
WINDOW_ICON_ORDER* lParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
- lParam = (WINDOW_ICON_ORDER*) malloc(sizeof(WINDOW_ICON_ORDER));
+ lParam = (WINDOW_ICON_ORDER*) calloc(1, sizeof(WINDOW_ICON_ORDER));
+ if (!lParam)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(lParam, windowIcon, sizeof(WINDOW_ICON_ORDER));
WLog_VRB(TAG, "update_message_WindowIcon");
if (windowIcon->iconInfo->cbBitsColor > 0)
{
lParam->iconInfo->bitsColor = (BYTE*) malloc(windowIcon->iconInfo->cbBitsColor);
+ if (!lParam->iconInfo->bitsColor)
+ goto out_fail;
CopyMemory(lParam->iconInfo->bitsColor, windowIcon->iconInfo->bitsColor, windowIcon->iconInfo->cbBitsColor);
}
if (windowIcon->iconInfo->cbBitsMask > 0)
{
lParam->iconInfo->bitsMask = (BYTE*) malloc(windowIcon->iconInfo->cbBitsMask);
+ if (!lParam->iconInfo->bitsMask)
+ goto out_fail;
CopyMemory(lParam->iconInfo->bitsMask, windowIcon->iconInfo->bitsMask, windowIcon->iconInfo->cbBitsMask);
}
if (windowIcon->iconInfo->cbColorTable > 0)
{
lParam->iconInfo->colorTable = (BYTE*) malloc(windowIcon->iconInfo->cbColorTable);
+ if (!lParam->iconInfo->colorTable)
+ goto out_fail;
CopyMemory(lParam->iconInfo->colorTable, windowIcon->iconInfo->colorTable, windowIcon->iconInfo->cbColorTable);
}
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, WindowIcon), (void*) wParam, (void*) lParam);
+ return TRUE;
+
+out_fail:
+ free(lParam->iconInfo->bitsColor);
+ free(lParam->iconInfo->bitsMask);
+ free(lParam->iconInfo->colorTable);
+ free(lParam);
+ free(wParam);
+ return FALSE;
+
}
-static void update_message_WindowCachedIcon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
+static BOOL update_message_WindowCachedIcon(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, WINDOW_CACHED_ICON_ORDER* windowCachedIcon)
{
WINDOW_ORDER_INFO* wParam;
WINDOW_CACHED_ICON_ORDER* lParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
lParam = (WINDOW_CACHED_ICON_ORDER*) malloc(sizeof(WINDOW_CACHED_ICON_ORDER));
+ if (!lParam)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(lParam, windowCachedIcon, sizeof(WINDOW_CACHED_ICON_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, WindowCachedIcon), (void*) wParam, (void*) lParam);
+ return TRUE;
}
-static void update_message_WindowDelete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL update_message_WindowDelete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
WINDOW_ORDER_INFO* wParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, WindowDelete), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_NotifyIconCreate(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
+static BOOL update_message_NotifyIconCreate(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
{
WINDOW_ORDER_INFO* wParam;
NOTIFY_ICON_STATE_ORDER* lParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
lParam = (NOTIFY_ICON_STATE_ORDER*) malloc(sizeof(NOTIFY_ICON_STATE_ORDER));
+ if (!lParam)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(lParam, notifyIconState, sizeof(NOTIFY_ICON_STATE_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, NotifyIconCreate), (void*) wParam, (void*) lParam);
+ return TRUE;
}
-static void update_message_NotifyIconUpdate(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
+static BOOL update_message_NotifyIconUpdate(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, NOTIFY_ICON_STATE_ORDER* notifyIconState)
{
WINDOW_ORDER_INFO* wParam;
NOTIFY_ICON_STATE_ORDER* lParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
lParam = (NOTIFY_ICON_STATE_ORDER*) malloc(sizeof(NOTIFY_ICON_STATE_ORDER));
+ if (!lParam)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(lParam, notifyIconState, sizeof(NOTIFY_ICON_STATE_ORDER));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, NotifyIconUpdate), (void*) wParam, (void*) lParam);
+ return TRUE;
}
-static void update_message_NotifyIconDelete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL update_message_NotifyIconDelete(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
WINDOW_ORDER_INFO* wParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, NotifyIconDelete), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_MonitoredDesktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, MONITORED_DESKTOP_ORDER* monitoredDesktop)
+static BOOL update_message_MonitoredDesktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo, MONITORED_DESKTOP_ORDER* monitoredDesktop)
{
WINDOW_ORDER_INFO* wParam;
MONITORED_DESKTOP_ORDER* lParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
lParam = (MONITORED_DESKTOP_ORDER*) malloc(sizeof(MONITORED_DESKTOP_ORDER));
+ if (!lParam)
+ {
+ free(wParam);
+ return FALSE;
+ }
CopyMemory(lParam, monitoredDesktop, sizeof(MONITORED_DESKTOP_ORDER));
lParam->windowIds = NULL;
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, MonitoredDesktop), (void*) wParam, (void*) lParam);
+ return TRUE;
}
-static void update_message_NonMonitoredDesktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
+static BOOL update_message_NonMonitoredDesktop(rdpContext* context, WINDOW_ORDER_INFO* orderInfo)
{
WINDOW_ORDER_INFO* wParam;
wParam = (WINDOW_ORDER_INFO*) malloc(sizeof(WINDOW_ORDER_INFO));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, orderInfo, sizeof(WINDOW_ORDER_INFO));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(WindowUpdate, NonMonitoredDesktop), (void*) wParam, NULL);
+ return TRUE;
}
/* Pointer Update */
-static void update_message_PointerPosition(rdpContext* context, POINTER_POSITION_UPDATE* pointerPosition)
+static BOOL update_message_PointerPosition(rdpContext* context, POINTER_POSITION_UPDATE* pointerPosition)
{
POINTER_POSITION_UPDATE* wParam;
wParam = (POINTER_POSITION_UPDATE*) malloc(sizeof(POINTER_POSITION_UPDATE));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, pointerPosition, sizeof(POINTER_POSITION_UPDATE));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PointerUpdate, PointerPosition), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_PointerSystem(rdpContext* context, POINTER_SYSTEM_UPDATE* pointerSystem)
+static BOOL update_message_PointerSystem(rdpContext* context, POINTER_SYSTEM_UPDATE* pointerSystem)
{
POINTER_SYSTEM_UPDATE* wParam;
wParam = (POINTER_SYSTEM_UPDATE*) malloc(sizeof(POINTER_SYSTEM_UPDATE));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, pointerSystem, sizeof(POINTER_SYSTEM_UPDATE));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PointerUpdate, PointerSystem), (void*) wParam, NULL);
+ return TRUE;
}
-static void update_message_PointerColor(rdpContext* context, POINTER_COLOR_UPDATE* pointerColor)
+static BOOL update_message_PointerColor(rdpContext* context, POINTER_COLOR_UPDATE* pointerColor)
{
POINTER_COLOR_UPDATE* wParam;
wParam = (POINTER_COLOR_UPDATE*) malloc(sizeof(POINTER_COLOR_UPDATE));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, pointerColor, sizeof(POINTER_COLOR_UPDATE));
wParam->andMaskData = wParam->xorMaskData = NULL;
if (wParam->lengthAndMask)
{
wParam->andMaskData = (BYTE*) malloc(wParam->lengthAndMask);
+ if (!wParam->andMaskData)
+ goto out_fail;
CopyMemory(wParam->andMaskData, pointerColor->andMaskData, wParam->lengthAndMask);
}
if (wParam->lengthXorMask)
{
wParam->xorMaskData = (BYTE*) malloc(wParam->lengthXorMask);
+ if (!wParam->xorMaskData)
+ goto out_fail;
CopyMemory(wParam->xorMaskData, pointerColor->xorMaskData, wParam->lengthXorMask);
}
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PointerUpdate, PointerColor), (void*) wParam, NULL);
+ return TRUE;
+
+out_fail:
+ free(wParam->andMaskData);
+ free(wParam->xorMaskData);
+ free(wParam);
+ return FALSE;
}
-static void update_message_PointerNew(rdpContext* context, POINTER_NEW_UPDATE* pointerNew)
+static BOOL update_message_PointerNew(rdpContext* context, POINTER_NEW_UPDATE* pointerNew)
{
POINTER_NEW_UPDATE* wParam;
wParam = (POINTER_NEW_UPDATE*) malloc(sizeof(POINTER_NEW_UPDATE));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, pointerNew, sizeof(POINTER_NEW_UPDATE));
wParam->colorPtrAttr.andMaskData = wParam->colorPtrAttr.xorMaskData = NULL;
if (wParam->colorPtrAttr.lengthAndMask)
{
wParam->colorPtrAttr.andMaskData = (BYTE*) malloc(wParam->colorPtrAttr.lengthAndMask);
+ if (!wParam->colorPtrAttr.andMaskData)
+ goto out_fail;
CopyMemory(wParam->colorPtrAttr.andMaskData, pointerNew->colorPtrAttr.andMaskData, wParam->colorPtrAttr.lengthAndMask);
}
if (wParam->colorPtrAttr.lengthXorMask)
{
wParam->colorPtrAttr.xorMaskData = (BYTE*) malloc(wParam->colorPtrAttr.lengthXorMask);
+ if (!wParam->colorPtrAttr.xorMaskData)
+ goto out_fail;
CopyMemory(wParam->colorPtrAttr.xorMaskData, pointerNew->colorPtrAttr.xorMaskData, wParam->colorPtrAttr.lengthXorMask);
}
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PointerUpdate, PointerNew), (void*) wParam, NULL);
+ return TRUE;
+
+out_fail:
+ free(wParam->colorPtrAttr.andMaskData);
+ free(wParam->colorPtrAttr.xorMaskData);
+ free(wParam);
+ return FALSE;
}
-static void update_message_PointerCached(rdpContext* context, POINTER_CACHED_UPDATE* pointerCached)
+static BOOL update_message_PointerCached(rdpContext* context, POINTER_CACHED_UPDATE* pointerCached)
{
POINTER_CACHED_UPDATE* wParam;
wParam = (POINTER_CACHED_UPDATE*) malloc(sizeof(POINTER_CACHED_UPDATE));
+ if (!wParam)
+ return FALSE;
CopyMemory(wParam, pointerCached, sizeof(POINTER_CACHED_UPDATE));
MessageQueue_Post(context->update->queue, (void*) context,
MakeMessageId(PointerUpdate, PointerCached), (void*) wParam, NULL);
+ return TRUE;
}
/* Message Queue */
/* Input */
-static void input_message_SynchronizeEvent(rdpInput* input, UINT32 flags)
+static BOOL input_message_SynchronizeEvent(rdpInput* input, UINT32 flags)
{
MessageQueue_Post(input->queue, (void*) input,
MakeMessageId(Input, SynchronizeEvent), (void*) (size_t) flags, NULL);
+ return TRUE;
}
-static void input_message_KeyboardEvent(rdpInput* input, UINT16 flags, UINT16 code)
+static BOOL input_message_KeyboardEvent(rdpInput* input, UINT16 flags, UINT16 code)
{
MessageQueue_Post(input->queue, (void*) input,
MakeMessageId(Input, KeyboardEvent), (void*) (size_t) flags, (void*) (size_t) code);
+ return TRUE;
}
-static void input_message_UnicodeKeyboardEvent(rdpInput* input, UINT16 flags, UINT16 code)
+static BOOL input_message_UnicodeKeyboardEvent(rdpInput* input, UINT16 flags, UINT16 code)
{
MessageQueue_Post(input->queue, (void*) input,
MakeMessageId(Input, UnicodeKeyboardEvent), (void*) (size_t) flags, (void*) (size_t) code);
+ return TRUE;
}
-static void input_message_MouseEvent(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+static BOOL input_message_MouseEvent(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
UINT32 pos = (x << 16) | y;
MessageQueue_Post(input->queue, (void*) input,
MakeMessageId(Input, MouseEvent), (void*) (size_t) flags, (void*) (size_t) pos);
+ return TRUE;
}
-static void input_message_ExtendedMouseEvent(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+static BOOL input_message_ExtendedMouseEvent(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
UINT32 pos = (x << 16) | y;
MessageQueue_Post(input->queue, (void*) input,
MakeMessageId(Input, ExtendedMouseEvent), (void*) (size_t) flags, (void*) (size_t) pos);
+ return TRUE;
}
-static void input_message_FocusInEvent(rdpInput* input, UINT16 toggleStates)
+static BOOL input_message_FocusInEvent(rdpInput* input, UINT16 toggleStates)
{
MessageQueue_Post(input->queue, (void*) input,
MakeMessageId(Input, FocusInEvent), (void*) (size_t) toggleStates, NULL);
+ return TRUE;
}
-static void input_message_KeyboardPauseEvent(rdpInput* input)
+static BOOL input_message_KeyboardPauseEvent(rdpInput* input)
{
MessageQueue_Post(input->queue, (void*) input,
MakeMessageId(Input, KeyboardPauseEvent), NULL, NULL);
+ return TRUE;
}
/* Event Queue */
{
wStream* s;
s = transport_send_stream_init(rdp->transport, 2048);
+ if (!s)
+ return NULL;
rdp_init_stream_data_pdu(rdp, s);
return s;
}
return 0;
}
-void update_write_surfcmd_surface_bits_header(wStream* s, SURFACE_BITS_COMMAND* cmd)
+BOOL update_write_surfcmd_surface_bits_header(wStream* s, SURFACE_BITS_COMMAND* cmd)
{
- Stream_EnsureRemainingCapacity(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH);
+ if (!Stream_EnsureRemainingCapacity(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH))
+ return FALSE;
Stream_Write_UINT16(s, CMDTYPE_STREAM_SURFACE_BITS);
Stream_Write_UINT16(s, cmd->width);
Stream_Write_UINT16(s, cmd->height);
Stream_Write_UINT32(s, cmd->bitmapDataLength);
+
+ return TRUE;
}
-void update_write_surfcmd_frame_marker(wStream* s, UINT16 frameAction, UINT32 frameId)
+BOOL update_write_surfcmd_frame_marker(wStream* s, UINT16 frameAction, UINT32 frameId)
{
- Stream_EnsureRemainingCapacity(s, SURFCMD_FRAME_MARKER_LENGTH);
+ if (!Stream_EnsureRemainingCapacity(s, SURFCMD_FRAME_MARKER_LENGTH))
+ return FALSE;
Stream_Write_UINT16(s, CMDTYPE_FRAME_MARKER);
Stream_Write_UINT16(s, frameAction);
Stream_Write_UINT32(s, frameId);
+ return TRUE;
}
int update_recv_surfcmds(rdpUpdate* update, UINT32 size, wStream* s);
-void update_write_surfcmd_surface_bits_header(wStream* s, SURFACE_BITS_COMMAND* cmd);
-void update_write_surfcmd_frame_marker(wStream* s, UINT16 frameAction, UINT32 frameId);
+BOOL update_write_surfcmd_surface_bits_header(wStream* s, SURFACE_BITS_COMMAND* cmd);
+BOOL update_write_surfcmd_frame_marker(wStream* s, UINT16 frameAction, UINT32 frameId);
#endif /* __SURFACE */
update_message_proxy_free(update->proxy);
}
-static void update_begin_paint(rdpContext* context)
+static BOOL update_begin_paint(rdpContext* context)
{
wStream* s;
rdpUpdate* update = context->update;
update->EndPaint(context);
s = fastpath_update_pdu_init_new(context->rdp->fastpath);
+ if (!s)
+ return FALSE;
Stream_SealLength(s);
Stream_Seek(s, 2); /* numberOrders (2 bytes) */
update->combineUpdates = TRUE;
update->numberOrders = 0;
update->us = s;
+ return TRUE;
}
-static void update_end_paint(rdpContext* context)
+static BOOL update_end_paint(rdpContext* context)
{
wStream* s;
int headerLength;
rdpUpdate* update = context->update;
if (!update->us)
- return;
+ return FALSE;
s = update->us;
headerLength = Stream_Length(s);
update->us = NULL;
Stream_Free(s, TRUE);
+ return TRUE;
}
static void update_flush(rdpContext* context)
return FALSE;
}
-static void update_set_bounds(rdpContext* context, rdpBounds* bounds)
+static BOOL update_set_bounds(rdpContext* context, rdpBounds* bounds)
{
rdpUpdate* update = context->update;
ZeroMemory(&update->currentBounds, sizeof(rdpBounds));
else
CopyMemory(&update->currentBounds, bounds, sizeof(rdpBounds));
+ return TRUE;
}
BOOL update_bounds_is_null(rdpBounds* bounds)
}
}
-static void update_send_refresh_rect(rdpContext* context, BYTE count, RECTANGLE_16* areas)
+static BOOL update_send_refresh_rect(rdpContext* context, BYTE count, RECTANGLE_16* areas)
{
wStream* s;
rdpRdp* rdp = context->rdp;
if (rdp->settings->RefreshRect)
{
+ BOOL ret;
s = rdp_data_pdu_init(rdp);
+ if (!s)
+ return FALSE;
update_write_refresh_rect(s, count, areas);
- rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_REFRESH_RECT, rdp->mcs->userId);
+ ret = rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_REFRESH_RECT, rdp->mcs->userId);
Stream_Release(s);
+ return ret;
}
+ return TRUE;
}
static void update_write_suppress_output(wStream* s, BYTE allow, RECTANGLE_16* area)
}
}
-static void update_send_suppress_output(rdpContext* context, BYTE allow, RECTANGLE_16* area)
+static BOOL update_send_suppress_output(rdpContext* context, BYTE allow, RECTANGLE_16* area)
{
wStream* s;
rdpRdp* rdp = context->rdp;
if (rdp->settings->SuppressOutput)
{
+ BOOL ret;
s = rdp_data_pdu_init(rdp);
+ if (!s)
+ return FALSE;
update_write_suppress_output(s, allow, area);
- rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SUPPRESS_OUTPUT, rdp->mcs->userId);
+ ret = rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SUPPRESS_OUTPUT, rdp->mcs->userId);
Stream_Release(s);
+ return ret;
}
+ return TRUE;
}
-static void update_send_surface_command(rdpContext* context, wStream* s)
+static BOOL update_send_surface_command(rdpContext* context, wStream* s)
{
wStream* update;
rdpRdp* rdp = context->rdp;
+ BOOL ret;
update = fastpath_update_pdu_init(rdp->fastpath);
- Stream_EnsureRemainingCapacity(update, Stream_GetPosition(s));
+ if (!update)
+ return FALSE;
+ if (!Stream_EnsureRemainingCapacity(update, Stream_GetPosition(s)))
+ {
+ ret = FALSE;
+ goto out_fail;
+ }
Stream_Write(update, Stream_Buffer(s), Stream_GetPosition(s));
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, update, FALSE);
+ ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, update, FALSE);
+
+out_fail:
Stream_Release(update);
+ return ret;
}
-static void update_send_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surfaceBitsCommand)
+static BOOL update_send_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surfaceBitsCommand)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret = FALSE;
update_force_flush(context);
s = fastpath_update_pdu_init(rdp->fastpath);
- Stream_EnsureRemainingCapacity(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH + (int) surfaceBitsCommand->bitmapDataLength);
- update_write_surfcmd_surface_bits_header(s, surfaceBitsCommand);
+ if (!s)
+ return FALSE;
+
+ if (!Stream_EnsureRemainingCapacity(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH + (int) surfaceBitsCommand->bitmapDataLength) ||
+ !update_write_surfcmd_surface_bits_header(s, surfaceBitsCommand))
+ goto out_fail;
+
Stream_Write(s, surfaceBitsCommand->bitmapData, surfaceBitsCommand->bitmapDataLength);
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s, surfaceBitsCommand->skipCompression);
+
+ if (!fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s, surfaceBitsCommand->skipCompression))
+ goto out_fail;
update_force_flush(context);
+ ret = TRUE;
+out_fail:
Stream_Release(s);
+ return ret;
}
-static void update_send_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker)
+static BOOL update_send_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret = FALSE;
update_force_flush(context);
s = fastpath_update_pdu_init(rdp->fastpath);
- update_write_surfcmd_frame_marker(s, surfaceFrameMarker->frameAction, surfaceFrameMarker->frameId);
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s, FALSE);
+ if (!s)
+ return FALSE;
+
+ if (!update_write_surfcmd_frame_marker(s, surfaceFrameMarker->frameAction, surfaceFrameMarker->frameId) ||
+ !fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s, FALSE))
+ goto out_fail;
update_force_flush(context);
+ ret = TRUE;
+out_fail:
Stream_Release(s);
+ return ret;
}
-static void update_send_surface_frame_bits(rdpContext* context, SURFACE_BITS_COMMAND* cmd, BOOL first, BOOL last, UINT32 frameId)
+static BOOL update_send_surface_frame_bits(rdpContext* context, SURFACE_BITS_COMMAND* cmd, BOOL first, BOOL last, UINT32 frameId)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret = FALSE;
update_force_flush(context);
s = fastpath_update_pdu_init(rdp->fastpath);
- Stream_EnsureRemainingCapacity(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH + (int) cmd->bitmapDataLength + 16);
+ if (!s)
+ return FALSE;
+ if (!Stream_EnsureRemainingCapacity(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH + (int) cmd->bitmapDataLength + 16))
+ goto out_fail;
if (first)
- update_write_surfcmd_frame_marker(s, SURFACECMD_FRAMEACTION_BEGIN, frameId);
+ {
+ if (!update_write_surfcmd_frame_marker(s, SURFACECMD_FRAMEACTION_BEGIN, frameId))
+ goto out_fail;
+ }
- update_write_surfcmd_surface_bits_header(s, cmd);
+ if (!update_write_surfcmd_surface_bits_header(s, cmd))
+ goto out_fail;
Stream_Write(s, cmd->bitmapData, cmd->bitmapDataLength);
-
if (last)
- update_write_surfcmd_frame_marker(s, SURFACECMD_FRAMEACTION_END, frameId);
+ {
+ if (!update_write_surfcmd_frame_marker(s, SURFACECMD_FRAMEACTION_END, frameId))
+ return FALSE;
+ }
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s, cmd->skipCompression);
+ ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s, cmd->skipCompression);
update_force_flush(context);
+out_fail:
Stream_Release(s);
+ return ret;
}
-static void update_send_frame_acknowledge(rdpContext* context, UINT32 frameId)
+static BOOL update_send_frame_acknowledge(rdpContext* context, UINT32 frameId)
{
wStream* s;
rdpRdp* rdp = context->rdp;
if (rdp->settings->ReceivedCapabilities[CAPSET_TYPE_FRAME_ACKNOWLEDGE])
{
+ BOOL ret;
s = rdp_data_pdu_init(rdp);
+ if (!s)
+ return FALSE;
Stream_Write_UINT32(s, frameId);
- rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FRAME_ACKNOWLEDGE, rdp->mcs->userId);
+ ret = rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_FRAME_ACKNOWLEDGE, rdp->mcs->userId);
Stream_Release(s);
+ return ret;
}
+ return TRUE;
}
-static void update_send_synchronize(rdpContext* context)
+static BOOL update_send_synchronize(rdpContext* context)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret;
s = fastpath_update_pdu_init(rdp->fastpath);
+ if (!s)
+ return FALSE;
Stream_Zero(s, 2); /* pad2Octets (2 bytes) */
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SYNCHRONIZE, s, FALSE);
+ ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SYNCHRONIZE, s, FALSE);
Stream_Release(s);
+ return ret;
}
-static void update_send_desktop_resize(rdpContext* context)
+static BOOL update_send_desktop_resize(rdpContext* context)
{
- rdp_server_reactivate(context->rdp);
+ return rdp_server_reactivate(context->rdp);
}
-static void update_send_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
+static BOOL update_send_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
{
wStream* s;
rdpRdp* rdp = context->rdp;
rdpUpdate* update = context->update;
+ BOOL ret = TRUE;
update_force_flush(context);
s = fastpath_update_pdu_init(rdp->fastpath);
- update_write_bitmap_update(update, s, bitmapUpdate);
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_BITMAP, s, bitmapUpdate->skipCompression);
+ if (!s)
+ return FALSE;
+ if (!update_write_bitmap_update(update, s, bitmapUpdate) ||
+ !fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_BITMAP, s, bitmapUpdate->skipCompression))
+ {
+ ret = FALSE;
+ goto out_fail;
+ }
update_force_flush(context);
+out_fail:
Stream_Release(s);
+ return ret;
}
-static void update_send_play_sound(rdpContext* context, PLAY_SOUND_UPDATE* play_sound)
+static BOOL update_send_play_sound(rdpContext* context, PLAY_SOUND_UPDATE* play_sound)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret;
if (!rdp->settings->ReceivedCapabilities[CAPSET_TYPE_SOUND]) {
- return;
+ return TRUE;
}
s = rdp_data_pdu_init(rdp);
+ if (!s)
+ return FALSE;
Stream_Write_UINT32(s, play_sound->duration);
Stream_Write_UINT32(s, play_sound->frequency);
- rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_PLAY_SOUND, rdp->mcs->userId);
+ ret = rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_PLAY_SOUND, rdp->mcs->userId);
Stream_Release(s);
+ return ret;
}
/**
* Primary Drawing Orders
*/
-static void update_send_dstblt(rdpContext* context, DSTBLT_ORDER* dstblt)
+static BOOL update_send_dstblt(rdpContext* context, DSTBLT_ORDER* dstblt)
{
wStream* s;
int offset;
update_check_flush(context, headerLength + update_approximate_dstblt_order(&orderInfo, dstblt));
s = update->us;
+ if (!s)
+ return FALSE;
offset = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
- update_write_dstblt_order(s, &orderInfo, dstblt);
+ if (!update_write_dstblt_order(s, &orderInfo, dstblt))
+ return FALSE;
update_write_order_info(context, s, &orderInfo, offset);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_patblt(rdpContext* context, PATBLT_ORDER* patblt)
+static BOOL update_send_patblt(rdpContext* context, PATBLT_ORDER* patblt)
{
wStream* s;
int offset;
update_check_flush(context, headerLength + update_approximate_patblt_order(&orderInfo, patblt));
s = update->us;
+ if (!s)
+ return FALSE;
offset = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
update_write_patblt_order(s, &orderInfo, patblt);
update_write_order_info(context, s, &orderInfo, offset);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_scrblt(rdpContext* context, SCRBLT_ORDER* scrblt)
+static BOOL update_send_scrblt(rdpContext* context, SCRBLT_ORDER* scrblt)
{
wStream* s;
int offset;
update_check_flush(context, headerLength + update_approximate_scrblt_order(&orderInfo, scrblt));
s = update->us;
+ if (!s)
+ return TRUE;
offset = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
update_write_scrblt_order(s, &orderInfo, scrblt);
update_write_order_info(context, s, &orderInfo, offset);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect)
+static BOOL update_send_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect)
{
wStream* s;
int offset;
update_check_flush(context, headerLength + update_approximate_opaque_rect_order(&orderInfo, opaque_rect));
s = update->us;
+ if (!s)
+ return FALSE;
offset = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
update_write_opaque_rect_order(s, &orderInfo, opaque_rect);
update_write_order_info(context, s, &orderInfo, offset);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_line_to(rdpContext* context, LINE_TO_ORDER* line_to)
+static BOOL update_send_line_to(rdpContext* context, LINE_TO_ORDER* line_to)
{
wStream* s;
int offset;
update_check_flush(context, headerLength + update_approximate_line_to_order(&orderInfo, line_to));
s = update->us;
+ if (!s)
+ return FALSE;
offset = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
update_write_line_to_order(s, &orderInfo, line_to);
update_write_order_info(context, s, &orderInfo, offset);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
+static BOOL update_send_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
{
wStream* s;
int offset;
update_check_flush(context, headerLength + update_approximate_memblt_order(&orderInfo, memblt));
s = update->us;
+ if (!s)
+ return FALSE;
offset = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
update_write_memblt_order(s, &orderInfo, memblt);
update_write_order_info(context, s, &orderInfo, offset);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_glyph_index(rdpContext* context, GLYPH_INDEX_ORDER* glyph_index)
+static BOOL update_send_glyph_index(rdpContext* context, GLYPH_INDEX_ORDER* glyph_index)
{
wStream* s;
int offset;
update_check_flush(context, headerLength + update_approximate_glyph_index_order(&orderInfo, glyph_index));
s = update->us;
+ if (!s)
+ return FALSE;
offset = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
update_write_glyph_index_order(s, &orderInfo, glyph_index);
update_write_order_info(context, s, &orderInfo, offset);
update->numberOrders++;
+ return TRUE;
}
/*
* Secondary Drawing Orders
*/
-static void update_send_cache_bitmap(rdpContext* context, CACHE_BITMAP_ORDER* cache_bitmap)
+static BOOL update_send_cache_bitmap(rdpContext* context, CACHE_BITMAP_ORDER* cache_bitmap)
{
wStream* s;
int bm, em;
update_check_flush(context, headerLength + update_approximate_cache_bitmap_order(cache_bitmap, cache_bitmap->compressed, &extraFlags));
s = update->us;
+ if (!s)
+ return FALSE;
+
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
+
Stream_Seek(s, headerLength);
- update_write_cache_bitmap_order(s, cache_bitmap, cache_bitmap->compressed, &extraFlags);
+ if (!update_write_cache_bitmap_order(s, cache_bitmap, cache_bitmap->compressed, &extraFlags))
+ return FALSE;
+
em = Stream_GetPosition(s);
orderLength = (em - bm) - 13;
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_cache_bitmap_v2(rdpContext* context, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2)
+static BOOL update_send_cache_bitmap_v2(rdpContext* context, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2)
{
wStream* s;
int bm, em;
update_check_flush(context, headerLength + update_approximate_cache_bitmap_v2_order(cache_bitmap_v2, cache_bitmap_v2->compressed, &extraFlags));
s = update->us;
+ if (!s)
+ return FALSE;
+
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
+
Stream_Seek(s, headerLength);
- update_write_cache_bitmap_v2_order(s, cache_bitmap_v2, cache_bitmap_v2->compressed, &extraFlags);
+ if (!update_write_cache_bitmap_v2_order(s, cache_bitmap_v2, cache_bitmap_v2->compressed, &extraFlags))
+ return FALSE;
+
em = Stream_GetPosition(s);
orderLength = (em - bm) - 13;
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_cache_bitmap_v3(rdpContext* context, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3)
+static BOOL update_send_cache_bitmap_v3(rdpContext* context, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3)
{
wStream* s;
int bm, em;
update_check_flush(context, headerLength + update_approximate_cache_bitmap_v3_order(cache_bitmap_v3, &extraFlags));
s = update->us;
+ if (!s)
+ return FALSE;
+
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
+
Stream_Seek(s, headerLength);
- update_write_cache_bitmap_v3_order(s, cache_bitmap_v3, &extraFlags);
+ if (!update_write_cache_bitmap_v3_order(s, cache_bitmap_v3, &extraFlags))
+ return FALSE;
+
em = Stream_GetPosition(s);
orderLength = (em - bm) - 13;
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_cache_color_table(rdpContext* context, CACHE_COLOR_TABLE_ORDER* cache_color_table)
+static BOOL update_send_cache_color_table(rdpContext* context, CACHE_COLOR_TABLE_ORDER* cache_color_table)
{
wStream* s;
UINT16 flags;
update_check_flush(context, headerLength + update_approximate_cache_color_table_order(cache_color_table, &flags));
s = update->us;
+ if (!s)
+ return FALSE;
+
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
+
Stream_Seek(s, headerLength);
- update_write_cache_color_table_order(s, cache_color_table, &flags);
+ if (!update_write_cache_color_table_order(s, cache_color_table, &flags))
+ return FALSE;
+
em = Stream_GetPosition(s);
orderLength = (em - bm) - 13;
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_cache_glyph(rdpContext* context, CACHE_GLYPH_ORDER* cache_glyph)
+static BOOL update_send_cache_glyph(rdpContext* context, CACHE_GLYPH_ORDER* cache_glyph)
{
wStream* s;
UINT16 flags;
update_check_flush(context, headerLength + update_approximate_cache_glyph_order(cache_glyph, &flags));
s = update->us;
+ if (!s)
+ return FALSE;
+
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
- update_write_cache_glyph_order(s, cache_glyph, &flags);
+ if (!update_write_cache_glyph_order(s, cache_glyph, &flags))
+ return FALSE;
+
em = Stream_GetPosition(s);
orderLength = (em - bm) - 13;
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_cache_glyph_v2(rdpContext* context, CACHE_GLYPH_V2_ORDER* cache_glyph_v2)
+static BOOL update_send_cache_glyph_v2(rdpContext* context, CACHE_GLYPH_V2_ORDER* cache_glyph_v2)
{
wStream* s;
UINT16 flags;
update_check_flush(context, headerLength + update_approximate_cache_glyph_v2_order(cache_glyph_v2, &flags));
s = update->us;
+ if (!s)
+ return FALSE;
+
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
- update_write_cache_glyph_v2_order(s, cache_glyph_v2, &flags);
+ if (!update_write_cache_glyph_v2_order(s, cache_glyph_v2, &flags))
+ return FALSE;
+
em = Stream_GetPosition(s);
orderLength = (em - bm) - 13;
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_cache_brush(rdpContext* context, CACHE_BRUSH_ORDER* cache_brush)
+static BOOL update_send_cache_brush(rdpContext* context, CACHE_BRUSH_ORDER* cache_brush)
{
wStream* s;
UINT16 flags;
update_check_flush(context, headerLength + update_approximate_cache_brush_order(cache_brush, &flags));
s = update->us;
+ if (!s)
+ return FALSE;
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
- update_write_cache_brush_order(s, cache_brush, &flags);
+ if (!update_write_cache_brush_order(s, cache_brush, &flags))
+ return FALSE;
+
em = Stream_GetPosition(s);
orderLength = (em - bm) - 13;
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
/**
* Alternate Secondary Drawing Orders
*/
-static void update_send_create_offscreen_bitmap_order(rdpContext* context, CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
+static BOOL update_send_create_offscreen_bitmap_order(rdpContext* context, CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
{
wStream* s;
int bm, em;
update_check_flush(context, headerLength + update_approximate_create_offscreen_bitmap_order(create_offscreen_bitmap));
s = update->us;
+ if (!s)
+ return FALSE;
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
- update_write_create_offscreen_bitmap_order(s, create_offscreen_bitmap);
+ if (!update_write_create_offscreen_bitmap_order(s, create_offscreen_bitmap))
+ return FALSE;
em = Stream_GetPosition(s);
Stream_SetPosition(s, bm);
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_switch_surface_order(rdpContext* context, SWITCH_SURFACE_ORDER* switch_surface)
+static BOOL update_send_switch_surface_order(rdpContext* context, SWITCH_SURFACE_ORDER* switch_surface)
{
wStream* s;
int bm, em;
update_check_flush(context, headerLength + update_approximate_switch_surface_order(switch_surface));
s = update->us;
+ if (!s)
+ return FALSE;
bm = Stream_GetPosition(s);
- Stream_EnsureRemainingCapacity(s, headerLength);
+ if (!Stream_EnsureRemainingCapacity(s, headerLength))
+ return FALSE;
Stream_Seek(s, headerLength);
- update_write_switch_surface_order(s, switch_surface);
+ if (!update_write_switch_surface_order(s, switch_surface))
+ return FALSE;
em = Stream_GetPosition(s);
Stream_SetPosition(s, bm);
Stream_SetPosition(s, em);
update->numberOrders++;
+ return TRUE;
}
-static void update_send_pointer_system(rdpContext* context, POINTER_SYSTEM_UPDATE* pointer_system)
+static BOOL update_send_pointer_system(rdpContext* context, POINTER_SYSTEM_UPDATE* pointer_system)
{
wStream* s;
BYTE updateCode;
rdpRdp* rdp = context->rdp;
+ BOOL ret;
s = fastpath_update_pdu_init(rdp->fastpath);
+ if (!s)
+ return FALSE;
if (pointer_system->type == SYSPTR_NULL)
updateCode = FASTPATH_UPDATETYPE_PTR_NULL;
else
updateCode = FASTPATH_UPDATETYPE_PTR_DEFAULT;
- fastpath_send_update_pdu(rdp->fastpath, updateCode, s, FALSE);
+ ret = fastpath_send_update_pdu(rdp->fastpath, updateCode, s, FALSE);
Stream_Release(s);
+ return ret;
}
-static void update_send_pointer_position(rdpContext* context, POINTER_POSITION_UPDATE* pointerPosition)
+static BOOL update_send_pointer_position(rdpContext* context, POINTER_POSITION_UPDATE* pointerPosition)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret = FALSE;
s = fastpath_update_pdu_init(rdp->fastpath);
+ if (!s)
+ return FALSE;
- Stream_EnsureRemainingCapacity(s, 16);
+ if (!Stream_EnsureRemainingCapacity(s, 16))
+ goto out_fail;
Stream_Write_UINT16(s, pointerPosition->xPos); /* xPos (2 bytes) */
Stream_Write_UINT16(s, pointerPosition->yPos); /* yPos (2 bytes) */
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_PTR_POSITION, s, FALSE);
+ ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_PTR_POSITION, s, FALSE);
+out_fail:
Stream_Release(s);
+ return ret;
}
-static void update_write_pointer_color(wStream* s, POINTER_COLOR_UPDATE* pointer_color)
+static BOOL update_write_pointer_color(wStream* s, POINTER_COLOR_UPDATE* pointer_color)
{
- Stream_EnsureRemainingCapacity(s, 32 + (int) pointer_color->lengthAndMask + (int) pointer_color->lengthXorMask);
+ if (!Stream_EnsureRemainingCapacity(s, 32 + (int) pointer_color->lengthAndMask + (int) pointer_color->lengthXorMask))
+ return FALSE;
Stream_Write_UINT16(s, pointer_color->cacheIndex);
Stream_Write_UINT16(s, pointer_color->xPos);
Stream_Write(s, pointer_color->andMaskData, pointer_color->lengthAndMask);
Stream_Write_UINT8(s, 0); /* pad (1 byte) */
+ return TRUE;
}
-static void update_send_pointer_color(rdpContext* context, POINTER_COLOR_UPDATE* pointer_color)
+static BOOL update_send_pointer_color(rdpContext* context, POINTER_COLOR_UPDATE* pointer_color)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret = FALSE;
s = fastpath_update_pdu_init(rdp->fastpath);
- update_write_pointer_color(s, pointer_color);
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_COLOR, s, FALSE);
+ if (!s)
+ return FALSE;
+
+ if (!update_write_pointer_color(s, pointer_color))
+ goto out_fail;
+
+ ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_COLOR, s, FALSE);
+
+out_fail:
Stream_Release(s);
+ return ret;
}
-static void update_send_pointer_new(rdpContext* context, POINTER_NEW_UPDATE* pointer_new)
+static BOOL update_send_pointer_new(rdpContext* context, POINTER_NEW_UPDATE* pointer_new)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret = FALSE;
s = fastpath_update_pdu_init(rdp->fastpath);
+ if (!s)
+ return FALSE;
- Stream_EnsureRemainingCapacity(s, 16);
+ if (!Stream_EnsureRemainingCapacity(s, 16))
+ goto out_fail;
Stream_Write_UINT16(s, pointer_new->xorBpp); /* xorBpp (2 bytes) */
update_write_pointer_color(s, &pointer_new->colorPtrAttr);
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_POINTER, s, FALSE);
+ ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_POINTER, s, FALSE);
+out_fail:
Stream_Release(s);
+ return ret;
}
-static void update_send_pointer_cached(rdpContext* context, POINTER_CACHED_UPDATE* pointer_cached)
+static BOOL update_send_pointer_cached(rdpContext* context, POINTER_CACHED_UPDATE* pointer_cached)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret;
s = fastpath_update_pdu_init(rdp->fastpath);
+ if (!s)
+ return FALSE;
Stream_Write_UINT16(s, pointer_cached->cacheIndex); /* cacheIndex (2 bytes) */
- fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_CACHED, s, FALSE);
+ ret = fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_CACHED, s, FALSE);
Stream_Release(s);
+ return ret;
}
BOOL update_read_refresh_rect(rdpUpdate* update, wStream* s)
return TRUE;
}
-static void update_send_set_keyboard_indicators(rdpContext* context, UINT16 led_flags)
+static BOOL update_send_set_keyboard_indicators(rdpContext* context, UINT16 led_flags)
{
wStream* s;
rdpRdp* rdp = context->rdp;
+ BOOL ret;
s = rdp_data_pdu_init(rdp);
+ if (!s)
+ return FALSE;
Stream_Write_UINT16(s, 0); /* unitId should be 0 according to MS-RDPBCGR 2.2.8.2.1.1 */
Stream_Write_UINT16(s, led_flags); /* ledFlags (2 bytes) */
- rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS, rdp->mcs->userId);
+ ret = rdp_send_data_pdu(rdp, s, DATA_PDU_TYPE_SET_KEYBOARD_INDICATORS, rdp->mcs->userId);
Stream_Release(s);
+ return ret;
}
void update_register_server_callbacks(rdpUpdate* update)
hBitmap->width = nWidth;
hBitmap->height = nHeight;
hBitmap->data = _aligned_malloc(nWidth * nHeight * hBitmap->bytesPerPixel, 16);
+ if (!hBitmap->data)
+ {
+ free(hBitmap);
+ return NULL;
+ }
hBitmap->scanline = nWidth * hBitmap->bytesPerPixel;
return hBitmap;
#endif
#include <stdio.h>
-#include <string.h>
#include <stdlib.h>
#include <freerdp/freerdp.h>
HGDI_BRUSH gdi_CreateSolidBrush(GDI_COLOR crColor)
{
HGDI_BRUSH hBrush = (HGDI_BRUSH) malloc(sizeof(GDI_BRUSH));
+ if (!hBrush)
+ return NULL;
hBrush->objectType = GDIOBJECT_BRUSH;
hBrush->style = GDI_BS_SOLID;
hBrush->color = crColor;
HGDI_BRUSH gdi_CreatePatternBrush(HGDI_BITMAP hbmp)
{
HGDI_BRUSH hBrush = (HGDI_BRUSH) malloc(sizeof(GDI_BRUSH));
+ if (!hBrush)
+ return NULL;
hBrush->objectType = GDIOBJECT_BRUSH;
hBrush->style = GDI_BS_PATTERN;
hBrush->pattern = hbmp;
HGDI_BRUSH gdi_CreateHatchBrush(HGDI_BITMAP hbmp)
{
HGDI_BRUSH hBrush = (HGDI_BRUSH) malloc(sizeof(GDI_BRUSH));
+ if (!hBrush)
+ return NULL;
hBrush->objectType = GDIOBJECT_BRUSH;
hBrush->style = GDI_BS_HATCHED;
hBrush->pattern = hbmp;
HGDI_DC gdi_GetDC()
{
HGDI_DC hDC = (HGDI_DC) malloc(sizeof(GDI_DC));
+ if (!hDC)
+ return NULL;
hDC->bytesPerPixel = 4;
hDC->bitsPerPixel = 32;
hDC->drawMode = GDI_R2_BLACK;
hDC->clip = gdi_CreateRectRgn(0, 0, 0, 0);
+ if (!hDC->clip)
+ {
+ free(hDC);
+ return NULL;
+ }
hDC->clip->null = 1;
hDC->hwnd = NULL;
return hDC;
HGDI_DC gdi_CreateCompatibleDC(HGDI_DC hdc)
{
HGDI_DC hDC = (HGDI_DC) malloc(sizeof(GDI_DC));
+ if (!hDC)
+ return NULL;
+
+ if (!(hDC->clip = gdi_CreateRectRgn(0, 0, 0, 0)))
+ {
+ free(hDC);
+ return NULL;
+ }
+ hDC->clip->null = 1;
hDC->bytesPerPixel = hdc->bytesPerPixel;
hDC->bitsPerPixel = hdc->bitsPerPixel;
hDC->drawMode = hdc->drawMode;
- hDC->clip = gdi_CreateRectRgn(0, 0, 0, 0);
- hDC->clip->null = 1;
hDC->hwnd = NULL;
hDC->alpha = hdc->alpha;
hDC->invert = hdc->invert;
else
{
/* Unknown GDI Object Type */
- return 0;
+ return NULL;
}
return previousSelectedObject;
{
HGDI_BRUSH hBrush = (HGDI_BRUSH) hgdiobject;
- if(hBrush->style == GDI_BS_PATTERN)
+ if (hBrush->style == GDI_BS_PATTERN || hBrush->style == GDI_BS_HATCHED)
{
if (hBrush->pattern != NULL)
gdi_DeleteObject((HGDIOBJECT) hBrush->pattern);
}
}
-static void gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
+static BOOL gdi_bitmap_update(rdpContext* context, BITMAP_UPDATE* bitmapUpdate)
{
int status;
int nXDst;
gdi->bitmap_buffer = (BYTE*) _aligned_realloc(gdi->bitmap_buffer, gdi->bitmap_size, 16);
if (!gdi->bitmap_buffer)
- return;
+ return FALSE;
}
if (compressed)
if (status < 0)
{
WLog_ERR(TAG, "bitmap decompression failure");
- return;
+ return FALSE;
}
pSrcData = gdi->bitmap_buffer;
gdi_InvalidateRegion(gdi->primary->hdc, nXDst, nYDst, nWidth, nHeight);
}
+ return TRUE;
}
-static void gdi_palette_update(rdpContext* context, PALETTE_UPDATE* palette)
+static BOOL gdi_palette_update(rdpContext* context, PALETTE_UPDATE* palette)
{
int index;
PALETTE_ENTRY* pe;
pe = &(palette->entries[index]);
palette32[index] = RGB32(pe->red, pe->green, pe->blue);
}
+ return TRUE;
}
-static void gdi_set_bounds(rdpContext* context, rdpBounds* bounds)
+static BOOL gdi_set_bounds(rdpContext* context, rdpBounds* bounds)
{
rdpGdi* gdi = context->gdi;
{
gdi_SetNullClipRgn(gdi->drawing->hdc);
}
+ return TRUE;
}
-static void gdi_dstblt(rdpContext* context, DSTBLT_ORDER* dstblt)
+static BOOL gdi_dstblt(rdpContext* context, DSTBLT_ORDER* dstblt)
{
rdpGdi* gdi = context->gdi;
- gdi_BitBlt(gdi->drawing->hdc, dstblt->nLeftRect, dstblt->nTopRect,
- dstblt->nWidth, dstblt->nHeight, NULL, 0, 0, gdi_rop3_code(dstblt->bRop));
+ if (gdi_BitBlt(gdi->drawing->hdc, dstblt->nLeftRect, dstblt->nTopRect,
+ dstblt->nWidth, dstblt->nHeight, NULL, 0, 0, gdi_rop3_code(dstblt->bRop)) != 1)
+ return FALSE;
+ return TRUE;
}
-static void gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
+static BOOL gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
{
BYTE* data;
rdpBrush* brush;
GDI_COLOR originalColor;
HGDI_BRUSH originalBrush;
rdpGdi* gdi = context->gdi;
+ BOOL ret = TRUE;
brush = &patblt->brush;
originalBrush = gdi->drawing->hdc->brush;
gdi->drawing->hdc->brush = gdi_CreateSolidBrush(foreColor);
+ if (!gdi->drawing->hdc->brush)
+ {
+ ret = FALSE;
+ goto out_error;
+ }
- gdi_PatBlt(gdi->drawing->hdc, patblt->nLeftRect, patblt->nTopRect,
- patblt->nWidth, patblt->nHeight, gdi_rop3_code(patblt->bRop));
+ if (gdi_PatBlt(gdi->drawing->hdc, patblt->nLeftRect, patblt->nTopRect,
+ patblt->nWidth, patblt->nHeight, gdi_rop3_code(patblt->bRop)) != 1)
+ ret = FALSE;
gdi_DeleteObject((HGDIOBJECT) gdi->drawing->hdc->brush);
gdi->drawing->hdc->brush = originalBrush;
HGDI_BITMAP hBmp;
data = (BYTE*) _aligned_malloc(8 * 8 * gdi->bytesPerPixel, 16);
+ if (!data)
+ {
+ ret = FALSE;
+ goto out_error;
+ }
hatched = GDI_BS_HATCHED_PATTERNS + (8 * brush->hatch);
hatched, backColor, foreColor, gdi->palette);
hBmp = gdi_CreateBitmap(8, 8, gdi->drawing->hdc->bitsPerPixel, data);
+ if (!hBmp)
+ {
+ _aligned_free(data);
+ ret = FALSE;
+ goto out_error;
+ }
originalBrush = gdi->drawing->hdc->brush;
gdi->drawing->hdc->brush = gdi_CreateHatchBrush(hBmp);
+ if (!gdi->drawing->hdc->brush)
+ {
+ _aligned_free(data);
+ ret = FALSE;
+ goto out_error;
+ }
- gdi_PatBlt(gdi->drawing->hdc, patblt->nLeftRect, patblt->nTopRect,
- patblt->nWidth, patblt->nHeight, gdi_rop3_code(patblt->bRop));
+ if (gdi_PatBlt(gdi->drawing->hdc, patblt->nLeftRect, patblt->nTopRect,
+ patblt->nWidth, patblt->nHeight, gdi_rop3_code(patblt->bRop)) != 1)
+ ret = FALSE;
gdi_DeleteObject((HGDIOBJECT) gdi->drawing->hdc->brush);
gdi->drawing->hdc->brush = originalBrush;
brushFormat = gdi_get_pixel_format(brush->bpp, FALSE);
data = (BYTE*) _aligned_malloc(8 * 8 * gdi->bytesPerPixel, 16);
+ if (!data)
+ {
+ ret = FALSE;
+ goto out_error;
+ }
freerdp_image_copy(data, gdi->format, -1, 0, 0,
8, 8, brush->data, brushFormat, -1, 0, 0, gdi->palette);
else
{
data = (BYTE*) _aligned_malloc(8 * 8 * gdi->bytesPerPixel, 16);
+ if (!data)
+ {
+ ret = FALSE;
+ goto out_error;
+ }
freerdp_image_copy_from_monochrome(data, gdi->format, -1, 0, 0, 8, 8,
brush->data, backColor, foreColor, gdi->palette);
}
hBmp = gdi_CreateBitmap(8, 8, gdi->drawing->hdc->bitsPerPixel, data);
+ if (!hBmp)
+ {
+ _aligned_free(data);
+ ret = FALSE;
+ goto out_error;
+ }
originalBrush = gdi->drawing->hdc->brush;
gdi->drawing->hdc->brush = gdi_CreatePatternBrush(hBmp);
+ if (!gdi->drawing->hdc->brush)
+ {
+ _aligned_free(data);
+ ret = FALSE;
+ goto out_error;
+ }
- gdi_PatBlt(gdi->drawing->hdc, patblt->nLeftRect, patblt->nTopRect,
- patblt->nWidth, patblt->nHeight, gdi_rop3_code(patblt->bRop));
+ if (gdi_PatBlt(gdi->drawing->hdc, patblt->nLeftRect, patblt->nTopRect,
+ patblt->nWidth, patblt->nHeight, gdi_rop3_code(patblt->bRop)) != 1)
+ ret = FALSE;
gdi_DeleteObject((HGDIOBJECT) gdi->drawing->hdc->brush);
gdi->drawing->hdc->brush = originalBrush;
WLog_ERR(TAG, "unimplemented brush style:%d", brush->style);
}
+out_error:
gdi_SetTextColor(gdi->drawing->hdc, originalColor);
+ return ret;
}
-static void gdi_scrblt(rdpContext* context, SCRBLT_ORDER* scrblt)
+static BOOL gdi_scrblt(rdpContext* context, SCRBLT_ORDER* scrblt)
{
rdpGdi* gdi = context->gdi;
- gdi_BitBlt(gdi->drawing->hdc, scrblt->nLeftRect, scrblt->nTopRect,
+ if (gdi_BitBlt(gdi->drawing->hdc, scrblt->nLeftRect, scrblt->nTopRect,
scrblt->nWidth, scrblt->nHeight, gdi->primary->hdc,
- scrblt->nXSrc, scrblt->nYSrc, gdi_rop3_code(scrblt->bRop));
+ scrblt->nXSrc, scrblt->nYSrc, gdi_rop3_code(scrblt->bRop)) != 1)
+ return FALSE;
+ return TRUE;
}
-static void gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect)
+static BOOL gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect)
{
GDI_RECT rect;
HGDI_BRUSH hBrush;
UINT32 brush_color;
rdpGdi* gdi = context->gdi;
+ BOOL ret = FALSE;
gdi_CRgnToRect(opaque_rect->nLeftRect, opaque_rect->nTopRect,
opaque_rect->nWidth, opaque_rect->nHeight, &rect);
brush_color = freerdp_convert_gdi_order_color(opaque_rect->color, gdi->srcBpp, gdi->format, gdi->palette);
hBrush = gdi_CreateSolidBrush(brush_color);
- gdi_FillRect(gdi->drawing->hdc, &rect, hBrush);
-
- gdi_DeleteObject((HGDIOBJECT) hBrush);
+ if (hBrush)
+ {
+ if (gdi_FillRect(gdi->drawing->hdc, &rect, hBrush) == 0)
+ ret = TRUE;
+ gdi_DeleteObject((HGDIOBJECT) hBrush);
+ }
+ return ret;
}
-static void gdi_multi_opaque_rect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
+static BOOL gdi_multi_opaque_rect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
{
int i;
GDI_RECT rect;
UINT32 brush_color;
DELTA_RECT* rectangle;
rdpGdi* gdi = context->gdi;
+ BOOL ret = TRUE;
for (i = 1; i < (int) multi_opaque_rect->numRectangles + 1; i++)
{
brush_color = freerdp_convert_gdi_order_color(multi_opaque_rect->color, gdi->srcBpp, gdi->format, gdi->palette);
hBrush = gdi_CreateSolidBrush(brush_color);
+ if (!hBrush)
+ {
+ ret = FALSE;
+ break;
+ }
gdi_FillRect(gdi->drawing->hdc, &rect, hBrush);
gdi_DeleteObject((HGDIOBJECT) hBrush);
}
+ return ret;
}
-static void gdi_line_to(rdpContext* context, LINE_TO_ORDER* lineTo)
+static BOOL gdi_line_to(rdpContext* context, LINE_TO_ORDER* lineTo)
{
UINT32 color;
HGDI_PEN hPen;
color = freerdp_convert_gdi_order_color(lineTo->penColor, gdi->srcBpp, gdi->format, gdi->palette);
hPen = gdi_CreatePen(lineTo->penStyle, lineTo->penWidth, (GDI_COLOR) color);
- gdi_SelectObject(gdi->drawing->hdc, (HGDIOBJECT) hPen);
+ if (!hPen)
+ return FALSE;
+ if (!gdi_SelectObject(gdi->drawing->hdc, (HGDIOBJECT) hPen))
+ {
+ gdi_DeleteObject((HGDIOBJECT) hPen);
+ return FALSE;
+ }
gdi_SetROP2(gdi->drawing->hdc, lineTo->bRop2);
gdi_MoveToEx(gdi->drawing->hdc, lineTo->nXStart, lineTo->nYStart, NULL);
gdi_LineTo(gdi->drawing->hdc, lineTo->nXEnd, lineTo->nYEnd);
gdi_DeleteObject((HGDIOBJECT) hPen);
+ return TRUE;
}
-static void gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
+static BOOL gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
{
int i;
INT32 x;
color = freerdp_convert_gdi_order_color(polyline->penColor, gdi->srcBpp, gdi->format, gdi->palette);
hPen = gdi_CreatePen(GDI_PS_SOLID, 1, (GDI_COLOR) color);
+ if (!hPen)
+ return FALSE;
gdi_SelectObject(gdi->drawing->hdc, (HGDIOBJECT) hPen);
gdi_SetROP2(gdi->drawing->hdc, polyline->bRop2);
}
gdi_DeleteObject((HGDIOBJECT) hPen);
+ return TRUE;
}
-static void gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
+static BOOL gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
{
gdiBitmap* bitmap;
rdpGdi* gdi = context->gdi;
gdi_BitBlt(gdi->drawing->hdc, memblt->nLeftRect, memblt->nTopRect,
memblt->nWidth, memblt->nHeight, bitmap->hdc,
memblt->nXSrc, memblt->nYSrc, gdi_rop3_code(memblt->bRop));
+ return TRUE;
}
-static void gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
+static BOOL gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
{
BYTE* data;
rdpBrush* brush;
GDI_COLOR originalColor;
HGDI_BRUSH originalBrush;
rdpGdi* gdi = context->gdi;
+ BOOL ret = TRUE;
brush = &mem3blt->brush;
bitmap = (gdiBitmap*) mem3blt->bitmap;
{
originalBrush = gdi->drawing->hdc->brush;
gdi->drawing->hdc->brush = gdi_CreateSolidBrush(foreColor);
+ if (!gdi->drawing->hdc->brush)
+ {
+ ret = FALSE;
+ goto out_fail;
+ }
gdi_BitBlt(gdi->drawing->hdc, mem3blt->nLeftRect, mem3blt->nTopRect,
mem3blt->nWidth, mem3blt->nHeight, bitmap->hdc,
brushFormat = gdi_get_pixel_format(brush->bpp, FALSE);
data = (BYTE*) _aligned_malloc(8 * 8 * gdi->bytesPerPixel, 16);
+ if (!data)
+ {
+ ret = FALSE;
+ goto out_fail;
+ }
freerdp_image_copy(data, gdi->format, -1, 0, 0,
8, 8, brush->data, brushFormat, -1, 0, 0, gdi->palette);
else
{
data = (BYTE*) _aligned_malloc(8 * 8 * gdi->bytesPerPixel, 16);
+ if (!data)
+ {
+ ret = FALSE;
+ goto out_fail;
+ }
freerdp_image_copy_from_monochrome(data, gdi->format, -1, 0, 0, 8, 8,
brush->data, backColor, foreColor, gdi->palette);
}
hBmp = gdi_CreateBitmap(8, 8, gdi->drawing->hdc->bitsPerPixel, data);
+ if (!hBmp)
+ {
+ _aligned_free(data);
+ ret = FALSE;
+ goto out_fail;
+ }
originalBrush = gdi->drawing->hdc->brush;
gdi->drawing->hdc->brush = gdi_CreatePatternBrush(hBmp);
+ if (!gdi->drawing->hdc->brush)
+ {
+ gdi_DeleteObject((HGDIOBJECT) hBmp);
+ goto out_fail;
+ }
gdi_BitBlt(gdi->drawing->hdc, mem3blt->nLeftRect, mem3blt->nTopRect,
mem3blt->nWidth, mem3blt->nHeight, bitmap->hdc,
WLog_ERR(TAG, "Mem3Blt unimplemented brush style:%d", brush->style);
}
+out_fail:
gdi_SetTextColor(gdi->drawing->hdc, originalColor);
+ return ret;
}
-static void gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc)
+static BOOL gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc)
{
WLog_VRB(TAG, "not implemented");
+ return TRUE;
}
-static void gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
+static BOOL gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
{
WLog_VRB(TAG, "not implemented");
+ return TRUE;
}
-static void gdi_ellipse_sc(rdpContext* context, ELLIPSE_SC_ORDER* ellipse_sc)
+static BOOL gdi_ellipse_sc(rdpContext* context, ELLIPSE_SC_ORDER* ellipse_sc)
{
WLog_VRB(TAG, "not implemented");
+ return TRUE;
}
-static void gdi_ellipse_cb(rdpContext* context, ELLIPSE_CB_ORDER* ellipse_cb)
+static BOOL gdi_ellipse_cb(rdpContext* context, ELLIPSE_CB_ORDER* ellipse_cb)
{
WLog_VRB(TAG, "not implemented");
+ return TRUE;
}
-static void gdi_frame_marker(rdpContext* context, FRAME_MARKER_ORDER* frameMarker)
+static BOOL gdi_frame_marker(rdpContext* context, FRAME_MARKER_ORDER* frameMarker)
{
-
-
+ return TRUE;
}
-void gdi_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker)
+BOOL gdi_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker)
{
DEBUG_GDI("frameId %d frameAction %d",
surfaceFrameMarker->frameId,
}
break;
}
+ return TRUE;
}
-static void gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* cmd)
+static BOOL gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* cmd)
{
int i, j;
int tx, ty;
gdi->bitmap_buffer = (BYTE*) _aligned_realloc(gdi->bitmap_buffer, gdi->bitmap_size, 16);
if (!gdi->bitmap_buffer)
- return;
+ return FALSE;
}
pDstData = gdi->bitmap_buffer;
gdi->bitmap_buffer = (BYTE*) _aligned_realloc(gdi->bitmap_buffer, gdi->bitmap_size, 16);
if (!gdi->bitmap_buffer)
- return;
+ return FALSE;
}
pDstData = gdi->bitmap_buffer;
{
WLog_ERR(TAG, "Unsupported codecID %d", cmd->codecID);
}
+ return TRUE;
}
/**
#include <freerdp/gdi/shape.h>
#include <freerdp/gdi/region.h>
#include <freerdp/gdi/bitmap.h>
-#include <freerdp/codec/jpeg.h>
-#include <freerdp/codec/rfx.h>
-#include <freerdp/codec/nsc.h>
#include <freerdp/gdi/drawing.h>
-#include <freerdp/gdi/clipping.h>
-#include <freerdp/codec/color.h>
-#include <freerdp/codec/bitmap.h>
-#include <freerdp/codec/bitmap.h>
-#include <freerdp/cache/glyph.h>
#include "graphics.h"
return bitmap;
}
-void gdi_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
+BOOL gdi_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
{
gdiBitmap* gdi_bitmap;
rdpGdi* gdi = context->gdi;
gdi_bitmap = (gdiBitmap*) bitmap;
gdi_bitmap->hdc = gdi_CreateCompatibleDC(gdi->hdc);
+ if (!gdi->hdc)
+ return FALSE;
if (!bitmap->data)
gdi_bitmap->bitmap = gdi_CreateCompatibleBitmap(gdi->hdc, bitmap->width, bitmap->height);
else
gdi_bitmap->bitmap = gdi_create_bitmap(gdi, bitmap->width, bitmap->height, bitmap->bpp, bitmap->data);
- gdi_SelectObject(gdi_bitmap->hdc, (HGDIOBJECT) gdi_bitmap->bitmap);
+ if (!gdi_bitmap->bitmap)
+ {
+ gdi_DeleteDC(gdi->hdc);
+ return FALSE;
+ }
+
+ if (!gdi_SelectObject(gdi_bitmap->hdc, (HGDIOBJECT) gdi_bitmap->bitmap))
+ {
+ gdi_DeleteObject((HGDIOBJECT) gdi_bitmap->bitmap);
+ gdi_DeleteDC(gdi->hdc);
+ return FALSE;
+ }
gdi_bitmap->org_bitmap = NULL;
+ return TRUE;
}
void gdi_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
}
}
-void gdi_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
+BOOL gdi_Bitmap_Paint(rdpContext* context, rdpBitmap* bitmap)
{
int width, height;
gdiBitmap* gdi_bitmap = (gdiBitmap*) bitmap;
width = bitmap->right - bitmap->left + 1;
height = bitmap->bottom - bitmap->top + 1;
- gdi_BitBlt(context->gdi->primary->hdc, bitmap->left, bitmap->top,
- width, height, gdi_bitmap->hdc, 0, 0, GDI_SRCCOPY);
+ if (gdi_BitBlt(context->gdi->primary->hdc, bitmap->left, bitmap->top,
+ width, height, gdi_bitmap->hdc, 0, 0, GDI_SRCCOPY) != 0)
+ return FALSE;
+ return TRUE;
}
-void gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
+BOOL gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
BYTE* data, int width, int height, int bpp, int length,
BOOL compressed, int codecId)
{
if (status < 0)
{
WLog_ERR(TAG, "Bitmap Decompression Failed");
- return;
+ return FALSE;
}
}
else
bitmap->compressed = FALSE;
bitmap->length = size;
bitmap->bpp = gdi->dstBpp;
+ return TRUE;
}
-void gdi_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
+BOOL gdi_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
{
rdpGdi* gdi = context->gdi;
gdi->drawing = gdi->primary;
else
gdi->drawing = (gdiBitmap*) bitmap;
+
+ return TRUE;
}
/* Glyph Class */
-void gdi_Glyph_New(rdpContext* context, rdpGlyph* glyph)
+BOOL gdi_Glyph_New(rdpContext* context, rdpGlyph* glyph)
{
BYTE* data;
gdiGlyph* gdi_glyph;
gdi_glyph = (gdiGlyph*) glyph;
gdi_glyph->hdc = gdi_GetDC();
+ if (!gdi_glyph->hdc)
+ return FALSE;
gdi_glyph->hdc->bytesPerPixel = 1;
gdi_glyph->hdc->bitsPerPixel = 1;
data = freerdp_glyph_convert(glyph->cx, glyph->cy, glyph->aj);
+ if (!data)
+ {
+ gdi_DeleteDC(gdi_glyph->hdc);
+ return FALSE;
+ }
gdi_glyph->bitmap = gdi_CreateBitmap(glyph->cx, glyph->cy, 1, data);
+ if (!gdi_glyph->bitmap)
+ {
+ gdi_DeleteDC(gdi_glyph->hdc);
+ _aligned_free(data);
+ return FALSE;
+ }
gdi_glyph->bitmap->bytesPerPixel = 1;
gdi_glyph->bitmap->bitsPerPixel = 1;
- gdi_SelectObject(gdi_glyph->hdc, (HGDIOBJECT) gdi_glyph->bitmap);
+ if (!gdi_SelectObject(gdi_glyph->hdc, (HGDIOBJECT) gdi_glyph->bitmap))
+ {
+ gdi_DeleteDC(gdi_glyph->hdc);
+ _aligned_free(data);
+ return FALSE;
+ }
gdi_glyph->org_bitmap = NULL;
+ return TRUE;
}
void gdi_Glyph_Free(rdpContext* context, rdpGlyph* glyph)
}
}
-void gdi_Glyph_Draw(rdpContext* context, rdpGlyph* glyph, int x, int y)
+BOOL gdi_Glyph_Draw(rdpContext* context, rdpGlyph* glyph, int x, int y)
{
gdiGlyph* gdi_glyph;
rdpGdi* gdi = context->gdi;
gdi_glyph = (gdiGlyph*) glyph;
- gdi_BitBlt(gdi->drawing->hdc, x, y, gdi_glyph->bitmap->width,
- gdi_glyph->bitmap->height, gdi_glyph->hdc, 0, 0, GDI_DSPDxax);
+ if (gdi_BitBlt(gdi->drawing->hdc, x, y, gdi_glyph->bitmap->width,
+ gdi_glyph->bitmap->height, gdi_glyph->hdc, 0, 0, GDI_DSPDxax) != 0)
+ return FALSE;
+ return TRUE;
}
-void gdi_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
+BOOL gdi_Glyph_BeginDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor, BOOL fOpRedundant)
{
GDI_RECT rect;
HGDI_BRUSH brush;
rdpGdi* gdi = context->gdi;
+ int ret = 1;
/* TODO: handle fOpRedundant! See xf_Glyph_BeginDraw() */
bgcolor = freerdp_convert_gdi_order_color(bgcolor, gdi->srcBpp, gdi->format, gdi->palette);
fgcolor = freerdp_convert_gdi_order_color(fgcolor, gdi->srcBpp, gdi->format, gdi->palette);
- gdi_CRgnToRect(x, y, width, height, &rect);
-
brush = gdi_CreateSolidBrush(fgcolor);
- gdi_FillRect(gdi->drawing->hdc, &rect, brush);
+ if (!brush)
+ {
+ goto out_fail;
+ return FALSE;
+ }
+
+ gdi_CRgnToRect(x, y, width, height, &rect);
+ ret = gdi_FillRect(gdi->drawing->hdc, &rect, brush);
gdi_DeleteObject((HGDIOBJECT) brush);
+out_fail:
gdi->textColor = gdi_SetTextColor(gdi->drawing->hdc, bgcolor);
+
+ if (ret != 0)
+ return FALSE;
+ return TRUE;
}
-void gdi_Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor)
+BOOL gdi_Glyph_EndDraw(rdpContext* context, int x, int y, int width, int height, UINT32 bgcolor, UINT32 fgcolor)
{
rdpGdi* gdi = context->gdi;
bgcolor = freerdp_convert_gdi_order_color(bgcolor, gdi->srcBpp, gdi->format, gdi->palette);
gdi->textColor = gdi_SetTextColor(gdi->drawing->hdc, bgcolor);
+ return TRUE;
}
/* Graphics Module */
-void gdi_register_graphics(rdpGraphics* graphics)
+BOOL gdi_register_graphics(rdpGraphics* graphics)
{
rdpBitmap* bitmap;
rdpGlyph* glyph;
bitmap = (rdpBitmap*) calloc(1, sizeof(rdpBitmap));
if (!bitmap)
- return;
+ return FALSE;
bitmap->size = sizeof(gdiBitmap);
glyph = (rdpGlyph*) calloc(1, sizeof(rdpGlyph));
if (!glyph)
- return;
+ return FALSE;
glyph->size = sizeof(gdiGlyph);
graphics_register_glyph(graphics, glyph);
free(glyph);
+ return TRUE;
}
HGDI_BITMAP gdi_create_bitmap(rdpGdi* gdi, int width, int height, int bpp, BYTE* data);
-void gdi_Bitmap_New(rdpContext* context, rdpBitmap* bitmap);
+BOOL gdi_Bitmap_New(rdpContext* context, rdpBitmap* bitmap);
void gdi_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap);
-void gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
+BOOL gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
BYTE* data, int width, int height, int bpp, int length,
BOOL compressed, int codec_id);
-void gdi_register_graphics(rdpGraphics* graphics);
+BOOL gdi_register_graphics(rdpGraphics* graphics);
#endif /* __GDI_GRAPHICS_H */
#endif
#include <stdio.h>
-#include <string.h>
#include <stdlib.h>
#include <freerdp/api.h>
HGDI_PEN gdi_CreatePen(int fnPenStyle, int nWidth, int crColor)
{
HGDI_PEN hPen = (HGDI_PEN) malloc(sizeof(GDI_PEN));
+ if (!hPen)
+ return NULL;
hPen->objectType = GDIOBJECT_PEN;
hPen->style = fnPenStyle;
hPen->color = crColor;
HGDI_RGN gdi_CreateRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
{
HGDI_RGN hRgn = (HGDI_RGN) malloc(sizeof(GDI_RGN));
+ if (!hRgn)
+ return NULL;
hRgn->objectType = GDIOBJECT_REGION;
hRgn->x = nLeftRect;
hRgn->y = nTopRect;
return TRUE;
}
-void tf_peer_synchronize_event(rdpInput* input, UINT32 flags)
+BOOL tf_peer_synchronize_event(rdpInput* input, UINT32 flags)
{
WLog_DBG(TAG, "Client sent a synchronize event (flags:0x%X)", flags);
+ return TRUE;
}
-void tf_peer_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL tf_peer_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
freerdp_peer* client = input->context->peer;
rdpUpdate* update = client->update;
{
}
+ return TRUE;
}
-void tf_peer_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL tf_peer_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
WLog_DBG(TAG, "Client sent a unicode keyboard event (flags:0x%X code:0x%X)", flags, code);
+ return TRUE;
}
-void tf_peer_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL tf_peer_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
//WLog_DBG(TAG, "Client sent a mouse event (flags:0x%X pos:%d,%d)", flags, x, y);
test_peer_draw_icon(input->context->peer, x + 10, y);
+ return TRUE;
}
-void tf_peer_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL tf_peer_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
//WLog_DBG(TAG, "Client sent an extended mouse event (flags:0x%X pos:%d,%d)", flags, x, y);
+ return TRUE;
}
-static void tf_peer_refresh_rect(rdpContext* context, BYTE count, RECTANGLE_16* areas)
+static BOOL tf_peer_refresh_rect(rdpContext* context, BYTE count, RECTANGLE_16* areas)
{
BYTE i;
WLog_DBG(TAG, "Client requested to refresh:");
{
WLog_DBG(TAG, " (%d, %d) (%d, %d)", areas[i].left, areas[i].top, areas[i].right, areas[i].bottom);
}
+ return TRUE;
}
-static void tf_peer_suppress_output(rdpContext* context, BYTE allow, RECTANGLE_16* area)
+static BOOL tf_peer_suppress_output(rdpContext* context, BYTE allow, RECTANGLE_16* area)
{
if (allow > 0)
{
{
WLog_DBG(TAG, "Client minimized and suppress output.");
}
+ return TRUE;
}
static void* test_peer_mainloop(void* arg)
WLog_INFO(TAG, "OnChannelDisconnected: %s", e->name);
}
-void shw_begin_paint(rdpContext* context)
+BOOL shw_begin_paint(rdpContext* context)
{
shwContext* shw;
rdpGdi* gdi = context->gdi;
gdi->primary->hdc->hwnd->invalid->null = 1;
gdi->primary->hdc->hwnd->ninvalid = 0;
+ return TRUE;
}
-void shw_end_paint(rdpContext* context)
+BOOL shw_end_paint(rdpContext* context)
{
int index;
int ninvalid;
SetEvent(subsystem->RdpUpdateEnterEvent);
WaitForSingleObject(subsystem->RdpUpdateLeaveEvent, INFINITE);
ResetEvent(subsystem->RdpUpdateLeaveEvent);
+ return TRUE;
}
-void shw_desktop_resize(rdpContext* context)
+BOOL shw_desktop_resize(rdpContext* context)
{
-
+ return TRUE;
}
-void shw_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker)
+BOOL shw_surface_frame_marker(rdpContext* context, SURFACE_FRAME_MARKER* surfaceFrameMarker)
{
shwContext* shw = (shwContext*) context;
+ return TRUE;
}
BOOL shw_authenticate(freerdp* instance, char** username, char** password, char** domain)
* Client Interface
*/
-void shw_freerdp_client_global_init(void)
+BOOL shw_freerdp_client_global_init(void)
{
-
+ return TRUE;
}
void shw_freerdp_client_global_uninit(void)
#include "shadow.h"
-void shadow_input_synchronize_event(rdpInput* input, UINT32 flags)
+BOOL shadow_input_synchronize_event(rdpInput* input, UINT32 flags)
{
rdpShadowClient* client = (rdpShadowClient*) input->context;
rdpShadowSubsystem* subsystem = client->server->subsystem;
if (!client->mayInteract)
- return;
+ return TRUE;
if (subsystem->SynchronizeEvent)
{
subsystem->SynchronizeEvent(subsystem, flags);
}
+ return TRUE;
}
-void shadow_input_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL shadow_input_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
rdpShadowClient* client = (rdpShadowClient*) input->context;
rdpShadowSubsystem* subsystem = client->server->subsystem;
if (!client->mayInteract)
- return;
+ return TRUE;
if (subsystem->KeyboardEvent)
{
subsystem->KeyboardEvent(subsystem, flags, code);
}
+ return TRUE;
}
-void shadow_input_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
+BOOL shadow_input_unicode_keyboard_event(rdpInput* input, UINT16 flags, UINT16 code)
{
rdpShadowClient* client = (rdpShadowClient*) input->context;
rdpShadowSubsystem* subsystem = client->server->subsystem;
if (!client->mayInteract)
- return;
+ return TRUE;
if (subsystem->UnicodeKeyboardEvent)
{
subsystem->UnicodeKeyboardEvent(subsystem, flags, code);
}
+ return TRUE;
}
-void shadow_input_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL shadow_input_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
rdpShadowClient* client = (rdpShadowClient*) input->context;
rdpShadowSubsystem* subsystem = client->server->subsystem;
flags &= ~PTR_FLAGS_MOVE;
if (!(flags & (PTR_FLAGS_BUTTON1 | PTR_FLAGS_BUTTON2 | PTR_FLAGS_BUTTON3)))
- return;
+ return TRUE;
}
}
if (!client->mayInteract)
- return;
+ return TRUE;
if (subsystem->MouseEvent)
{
subsystem->MouseEvent(subsystem, flags, x, y);
}
+ return TRUE;
}
-void shadow_input_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
+BOOL shadow_input_extended_mouse_event(rdpInput* input, UINT16 flags, UINT16 x, UINT16 y)
{
rdpShadowClient* client = (rdpShadowClient*) input->context;
rdpShadowSubsystem* subsystem = client->server->subsystem;
client->pointerY = y;
if (!client->mayInteract)
- return;
+ return TRUE;
if (subsystem->ExtendedMouseEvent)
{
subsystem->ExtendedMouseEvent(subsystem, flags, x, y);
}
+ return TRUE;
}
void shadow_input_register_callbacks(rdpInput* input)
projects / platform / upstream / freerdp.git / commitdiff