mirrors
/
FreeRDP
mirror of https://github.com/FreeRDP/FreeRDP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:FreeRDP/FreeRDP

This commit is contained in:
Marc-André Moreau 2011-10-16 23:46:12 -04:00
parent 39593a7f5e 0070a5ab93
commit 1f6d0a510e
18 changed files with 191 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
client/DirectFB/dfreerdp.c
View File

@ -46,7 +46,8 @@ void df_context_size(freerdp* instance, uint32* size)
void df_context_new(freerdp* instance, dfContext* context) void df_context_new(freerdp* instance, dfContext* context)
{ {
context->channels = freerdp_channels_new(); rdpContext* _context = (rdpContext*) context;
_context->channels = freerdp_channels_new();
} }
void df_context_free(freerdp* instance, dfContext* context) void df_context_free(freerdp* instance, dfContext* context)
@ -148,7 +149,7 @@ boolean df_pre_connect(freerdp* instance)
settings->order_support[NEG_ELLIPSE_SC_INDEX] = False; settings->order_support[NEG_ELLIPSE_SC_INDEX] = False;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = False; settings->order_support[NEG_ELLIPSE_CB_INDEX] = False;
freerdp_channels_pre_connect(context->channels, instance); freerdp_channels_pre_connect(instance->context->channels, instance);
return True; return True;
} }
@ -201,7 +202,7 @@ boolean df_post_connect(freerdp* instance)
df_keyboard_init(); df_keyboard_init();
freerdp_channels_post_connect(context->channels, instance); freerdp_channels_post_connect(instance->context->channels, instance);
return True; return True;
} }
@ -209,10 +210,10 @@ boolean df_post_connect(freerdp* instance)
static int df_process_plugin_args(rdpSettings* settings, const char* name, static int df_process_plugin_args(rdpSettings* settings, const char* name,
RDP_PLUGIN_DATA* plugin_data, void* user_data) RDP_PLUGIN_DATA* plugin_data, void* user_data)
{ {
rdpChannels* chanman = (rdpChannels*) user_data; rdpChannels* channels = (rdpChannels*) user_data;
printf("loading plugin %s\n", name); printf("loading plugin %s\n", name);
freerdp_channels_load_plugin(chanman, settings, name, plugin_data); freerdp_channels_load_plugin(channels, settings, name, plugin_data);
return 1; return 1;
} }
@ -224,7 +225,7 @@ df_receive_channel_data(freerdp* instance, int channelId, uint8* data, int size,
} }
static void static void
df_process_cb_sync_event(rdpChannels* chanman, freerdp* instance) df_process_cb_sync_event(rdpChannels* channels, freerdp* instance)
{ {
RDP_EVENT* event; RDP_EVENT* event;
RDP_CB_FORMAT_LIST_EVENT* format_list_event; RDP_CB_FORMAT_LIST_EVENT* format_list_event;
@ -234,22 +235,22 @@ df_process_cb_sync_event(rdpChannels* chanman, freerdp* instance)
format_list_event = (RDP_CB_FORMAT_LIST_EVENT*)event; format_list_event = (RDP_CB_FORMAT_LIST_EVENT*)event;
format_list_event->num_formats = 0; format_list_event->num_formats = 0;
freerdp_channels_send_event(chanman, event); freerdp_channels_send_event(channels, event);
} }
static void static void
df_process_channel_event(rdpChannels* chanman, freerdp* instance) df_process_channel_event(rdpChannels* channels, freerdp* instance)
{ {
RDP_EVENT* event; RDP_EVENT* event;
event = freerdp_channels_pop_event(chanman); event = freerdp_channels_pop_event(channels);
if (event) if (event)
{ {
switch (event->event_type) switch (event->event_type)
{ {
case RDP_EVENT_TYPE_CB_SYNC: case RDP_EVENT_TYPE_CB_SYNC:
df_process_cb_sync_event(chanman, instance); df_process_cb_sync_event(channels, instance);
break; break;
default: default:
printf("df_process_channel_event: unknown event type %d\n", event->event_type); printf("df_process_channel_event: unknown event type %d\n", event->event_type);
@ -279,30 +280,30 @@ int dfreerdp_run(freerdp* instance)
fd_set wfds_set; fd_set wfds_set;
dfInfo* dfi; dfInfo* dfi;
dfContext* context; dfContext* context;
rdpChannels* chanman; rdpChannels* channels;
memset(rfds, 0, sizeof(rfds)); memset(rfds, 0, sizeof(rfds));
memset(wfds, 0, sizeof(wfds)); memset(wfds, 0, sizeof(wfds));
if (!instance->Connect(instance)) if (!freerdp_connect(instance))
return 0; return 0;
context = (dfContext*) instance->context; context = (dfContext*) instance->context;
dfi = context->dfi; dfi = context->dfi;
chanman = context->channels; channels = instance->context->channels;
while (1) while (1)
{ {
rcount = 0; rcount = 0;
wcount = 0; wcount = 0;
if (instance->GetFileDescriptor(instance, rfds, &rcount, wfds, &wcount) != True) if (freerdp_get_fds(instance, rfds, &rcount, wfds, &wcount) != True)
{ {
printf("Failed to get FreeRDP file descriptor\n"); printf("Failed to get FreeRDP file descriptor\n");
break; break;
} }
if (freerdp_channels_get_fds(chanman, instance, rfds, &rcount, wfds, &wcount) != True) if (freerdp_channels_get_fds(channels, instance, rfds, &rcount, wfds, &wcount) != True)
{ {
printf("Failed to get channel manager file descriptor\n"); printf("Failed to get channel manager file descriptor\n");
break; break;
@ -343,7 +344,7 @@ int dfreerdp_run(freerdp* instance)
} }
} }
if (instance->CheckFileDescriptor(instance) != True) if (freerdp_check_fds(instance) != True)
{ {
printf("Failed to check FreeRDP file descriptor\n"); printf("Failed to check FreeRDP file descriptor\n");
break; break;
@ -353,19 +354,19 @@ int dfreerdp_run(freerdp* instance)
printf("Failed to check dfreerdp file descriptor\n"); printf("Failed to check dfreerdp file descriptor\n");
break; break;
} }
if (freerdp_channels_check_fds(chanman, instance) != True) if (freerdp_channels_check_fds(channels, instance) != True)
{ {
printf("Failed to check channel manager file descriptor\n"); printf("Failed to check channel manager file descriptor\n");
break; break;
} }
df_process_channel_event(chanman, instance); df_process_channel_event(channels, instance);
} }
freerdp_channels_close(chanman, instance); freerdp_channels_close(channels, instance);
freerdp_channels_free(chanman); freerdp_channels_free(channels);
df_free(dfi); df_free(dfi);
gdi_free(instance); gdi_free(instance);
instance->Disconnect(instance); freerdp_disconnect(instance);
freerdp_free(instance); freerdp_free(instance);
return 0; return 0;
@ -395,8 +396,8 @@ int main(int argc, char* argv[])
pthread_t thread; pthread_t thread;
freerdp* instance; freerdp* instance;
dfContext* context; dfContext* context;
rdpChannels* channels;
struct thread_data* data; struct thread_data* data;
rdpChannels* chanman;
setlocale(LC_ALL, ""); setlocale(LC_ALL, "");
@ -415,10 +416,10 @@ int main(int argc, char* argv[])
freerdp_context_new(instance); freerdp_context_new(instance);
context = (dfContext*) instance->context; context = (dfContext*) instance->context;
chanman = context->channels; channels = instance->context->channels;
DirectFBInit(&argc, &argv); DirectFBInit(&argc, &argv);
freerdp_parse_args(instance->settings, argc, argv, df_process_plugin_args, chanman, NULL, NULL); freerdp_parse_args(instance->settings, argc, argv, df_process_plugin_args, channels, NULL, NULL);
data = (struct thread_data*) xzalloc(sizeof(struct thread_data)); data = (struct thread_data*) xzalloc(sizeof(struct thread_data));
data->instance = instance; data->instance = instance;

1
client/DirectFB/dfreerdp.h
View File

@ -35,7 +35,6 @@ struct df_context
rdpContext _p; rdpContext _p;
dfInfo* dfi; dfInfo* dfi;
rdpChannels* channels;
rdpSettings* settings; rdpSettings* settings;
}; };
typedef struct df_context dfContext; typedef struct df_context dfContext;

4
client/X11/xf_gdi.c
View File

@ -382,7 +382,7 @@ void xf_gdi_patblt(rdpUpdate* update, PATBLT_ORDER* patblt)
if (brush->style & CACHED_BRUSH) if (brush->style & CACHED_BRUSH)
{ {
brush->data = brush_get(cache->brush, brush->index, &brush->bpp); brush->data = brush_cache_get(cache->brush, brush->index, &brush->bpp);
brush->style = GDI_BS_PATTERN; brush->style = GDI_BS_PATTERN;
} }
@ -823,7 +823,7 @@ void xf_gdi_cache_glyph_v2(rdpUpdate* update, CACHE_GLYPH_V2_ORDER* cache_glyph_
void xf_gdi_cache_brush(rdpUpdate* update, CACHE_BRUSH_ORDER* cache_brush) void xf_gdi_cache_brush(rdpUpdate* update, CACHE_BRUSH_ORDER* cache_brush)
{ {
rdpCache* cache = update->context->cache; rdpCache* cache = update->context->cache;
brush_put(cache->brush, cache_brush->index, cache_brush->data, cache_brush->bpp); brush_cache_put(cache->brush, cache_brush->index, cache_brush->data, cache_brush->bpp);
} }
void xf_gdi_surface_bits(rdpUpdate* update, SURFACE_BITS_COMMAND* surface_bits_command) void xf_gdi_surface_bits(rdpUpdate* update, SURFACE_BITS_COMMAND* surface_bits_command)

56
client/X11/xf_rail.c
View File

@ -195,7 +195,7 @@ static void xf_on_free_rail_client_event(RDP_EVENT* event)
} }
} }
static void xf_send_rail_client_event(rdpChannels* chanman, uint16 event_type, void* param) static void xf_send_rail_client_event(rdpChannels* channels, uint16 event_type, void* param)
{ {
RDP_EVENT* out_event = NULL; RDP_EVENT* out_event = NULL;
void * payload = NULL; void * payload = NULL;
@ -205,16 +205,16 @@ static void xf_send_rail_client_event(rdpChannels* chanman, uint16 event_type, v
{ {
out_event = freerdp_event_new(RDP_EVENT_CLASS_RAIL, event_type, out_event = freerdp_event_new(RDP_EVENT_CLASS_RAIL, event_type,
xf_on_free_rail_client_event, payload); xf_on_free_rail_client_event, payload);
freerdp_channels_send_event(chanman, out_event); freerdp_channels_send_event(channels, out_event);
} }
} }
void xf_rail_send_windowmove(xfInfo* xfi, uint32 windowId, uint32 left, uint32 top, uint32 right, uint32 bottom) void xf_rail_send_windowmove(xfInfo* xfi, uint32 windowId, uint32 left, uint32 top, uint32 right, uint32 bottom)
{ {
rdpChannels* chanman; rdpChannels* channels;
RAIL_WINDOW_MOVE_ORDER window_move; RAIL_WINDOW_MOVE_ORDER window_move;
chanman = xfi->context->channels; channels = xfi->_context->channels;
window_move.windowId = windowId; window_move.windowId = windowId;
window_move.left = left; window_move.left = left;
@ -222,18 +222,18 @@ void xf_rail_send_windowmove(xfInfo* xfi, uint32 windowId, uint32 left, uint32 t
window_move.right = right; window_move.right = right;
window_move.bottom = bottom; window_move.bottom = bottom;
xf_send_rail_client_event(chanman, RDP_EVENT_TYPE_RAIL_CLIENT_WINDOW_MOVE, &window_move); xf_send_rail_client_event(channels, RDP_EVENT_TYPE_RAIL_CLIENT_WINDOW_MOVE, &window_move);
} }
void xf_rail_send_activate(xfInfo* xfi, Window xwindow, boolean enabled) void xf_rail_send_activate(xfInfo* xfi, Window xwindow, boolean enabled)
{ {
rdpRail* rail; rdpRail* rail;
rdpChannels* chanman; rdpChannels* channels;
rdpWindow* rail_window; rdpWindow* rail_window;
RAIL_ACTIVATE_ORDER activate; RAIL_ACTIVATE_ORDER activate;
chanman = xfi->context->channels; rail = xfi->_context->rail;
rail = ((rdpContext*) xfi->context)->rail; channels = xfi->_context->channels;
rail_window = window_list_get_by_extra_id(rail->list, (void*) xwindow); rail_window = window_list_get_by_extra_id(rail->list, (void*) xwindow);
@ -243,23 +243,23 @@ void xf_rail_send_activate(xfInfo* xfi, Window xwindow, boolean enabled)
activate.windowId = rail_window->windowId; activate.windowId = rail_window->windowId;
activate.enabled = enabled; activate.enabled = enabled;
xf_send_rail_client_event(chanman, RDP_EVENT_TYPE_RAIL_CLIENT_ACTIVATE, &activate); xf_send_rail_client_event(channels, RDP_EVENT_TYPE_RAIL_CLIENT_ACTIVATE, &activate);
} }
void xf_rail_send_client_system_command(xfInfo* xfi, uint32 windowId, uint16 command) void xf_rail_send_client_system_command(xfInfo* xfi, uint32 windowId, uint16 command)
{ {
rdpChannels* chanman; rdpChannels* channels;
RAIL_SYSCOMMAND_ORDER syscommand; RAIL_SYSCOMMAND_ORDER syscommand;
chanman = xfi->context->channels; channels = xfi->_context->channels;
syscommand.windowId = windowId; syscommand.windowId = windowId;
syscommand.command = command; syscommand.command = command;
xf_send_rail_client_event(chanman, RDP_EVENT_TYPE_RAIL_CLIENT_SYSCOMMAND, &syscommand); xf_send_rail_client_event(channels, RDP_EVENT_TYPE_RAIL_CLIENT_SYSCOMMAND, &syscommand);
} }
void xf_process_rail_get_sysparams_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event) void xf_process_rail_get_sysparams_event(xfInfo* xfi, rdpChannels* channels, RDP_EVENT* event)
{ {
RAIL_SYSPARAM_ORDER* sysparam; RAIL_SYSPARAM_ORDER* sysparam;
@ -277,7 +277,7 @@ void xf_process_rail_get_sysparams_event(xfInfo* xfi, rdpChannels* chanman, RDP_
sysparam->dragFullWindows = False; sysparam->dragFullWindows = False;
xf_send_rail_client_event(chanman, RDP_EVENT_TYPE_RAIL_CLIENT_SET_SYSPARAMS, sysparam); xf_send_rail_client_event(channels, RDP_EVENT_TYPE_RAIL_CLIENT_SET_SYSPARAMS, sysparam);
} }
const char* error_code_names[] = const char* error_code_names[] =
@ -291,7 +291,7 @@ const char* error_code_names[] =
"RAIL_EXEC_E_SESSION_LOCKED" "RAIL_EXEC_E_SESSION_LOCKED"
}; };
void xf_process_rail_exec_result_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event) void xf_process_rail_exec_result_event(xfInfo* xfi, rdpChannels* channels, RDP_EVENT* event)
{ {
RAIL_EXEC_RESULT_ORDER* exec_result; RAIL_EXEC_RESULT_ORDER* exec_result;
@ -304,7 +304,7 @@ void xf_process_rail_exec_result_event(xfInfo* xfi, rdpChannels* chanman, RDP_EV
} }
} }
void xf_process_rail_server_sysparam_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event) void xf_process_rail_server_sysparam_event(xfInfo* xfi, rdpChannels* channels, RDP_EVENT* event)
{ {
RAIL_SYSPARAM_ORDER* sysparam = (RAIL_SYSPARAM_ORDER*) event->user_data; RAIL_SYSPARAM_ORDER* sysparam = (RAIL_SYSPARAM_ORDER*) event->user_data;
@ -318,7 +318,7 @@ void xf_process_rail_server_sysparam_event(xfInfo* xfi, rdpChannels* chanman, RD
} }
} }
void xf_process_rail_server_minmaxinfo_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event) void xf_process_rail_server_minmaxinfo_event(xfInfo* xfi, rdpChannels* channels, RDP_EVENT* event)
{ {
rdpRail* rail; rdpRail* rail;
rdpWindow* rail_window = NULL; rdpWindow* rail_window = NULL;
@ -360,7 +360,7 @@ const char* movetype_names[] =
"RAIL_WMSZ_KEYSIZE" "RAIL_WMSZ_KEYSIZE"
}; };
void xf_process_rail_server_localmovesize_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event) void xf_process_rail_server_localmovesize_event(xfInfo* xfi, rdpChannels* channels, RDP_EVENT* event)
{ {
rdpRail* rail; rdpRail* rail;
rdpWindow* rail_window = NULL; rdpWindow* rail_window = NULL;
@ -386,7 +386,7 @@ void xf_process_rail_server_localmovesize_event(xfInfo* xfi, rdpChannels* chanma
} }
void xf_process_rail_appid_resp_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event) void xf_process_rail_appid_resp_event(xfInfo* xfi, rdpChannels* channels, RDP_EVENT* event)
{ {
RAIL_GET_APPID_RESP_ORDER* appid_resp = RAIL_GET_APPID_RESP_ORDER* appid_resp =
(RAIL_GET_APPID_RESP_ORDER*)event->user_data; (RAIL_GET_APPID_RESP_ORDER*)event->user_data;
@ -398,7 +398,7 @@ void xf_process_rail_appid_resp_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVE
freerdp_hexdump(appid_resp->applicationId.string, appid_resp->applicationId.length); freerdp_hexdump(appid_resp->applicationId.string, appid_resp->applicationId.length);
} }
void xf_process_rail_langbarinfo_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event) void xf_process_rail_langbarinfo_event(xfInfo* xfi, rdpChannels* channels, RDP_EVENT* event)
{ {
RAIL_LANGBAR_INFO_ORDER* langbar = RAIL_LANGBAR_INFO_ORDER* langbar =
(RAIL_LANGBAR_INFO_ORDER*) event->user_data; (RAIL_LANGBAR_INFO_ORDER*) event->user_data;
@ -407,36 +407,36 @@ void xf_process_rail_langbarinfo_event(xfInfo* xfi, rdpChannels* chanman, RDP_EV
langbar->languageBarStatus); langbar->languageBarStatus);
} }
void xf_process_rail_event(xfInfo* xfi, rdpChannels* chanman, RDP_EVENT* event) void xf_process_rail_event(xfInfo* xfi, rdpChannels* channels, RDP_EVENT* event)
{ {
switch (event->event_type) switch (event->event_type)
{ {
case RDP_EVENT_TYPE_RAIL_CHANNEL_GET_SYSPARAMS: case RDP_EVENT_TYPE_RAIL_CHANNEL_GET_SYSPARAMS:
xf_process_rail_get_sysparams_event(xfi, chanman, event); xf_process_rail_get_sysparams_event(xfi, channels, event);
break; break;
case RDP_EVENT_TYPE_RAIL_CHANNEL_EXEC_RESULTS: case RDP_EVENT_TYPE_RAIL_CHANNEL_EXEC_RESULTS:
xf_process_rail_exec_result_event(xfi, chanman, event); xf_process_rail_exec_result_event(xfi, channels, event);
break; break;
case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_SYSPARAM: case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_SYSPARAM:
xf_process_rail_server_sysparam_event(xfi, chanman, event); xf_process_rail_server_sysparam_event(xfi, channels, event);
break; break;
case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_MINMAXINFO: case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_MINMAXINFO:
xf_process_rail_server_minmaxinfo_event(xfi, chanman, event); xf_process_rail_server_minmaxinfo_event(xfi, channels, event);
break; break;
case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_LOCALMOVESIZE: case RDP_EVENT_TYPE_RAIL_CHANNEL_SERVER_LOCALMOVESIZE:
xf_process_rail_server_localmovesize_event(xfi, chanman, event); xf_process_rail_server_localmovesize_event(xfi, channels, event);
break; break;
case RDP_EVENT_TYPE_RAIL_CHANNEL_APPID_RESP: case RDP_EVENT_TYPE_RAIL_CHANNEL_APPID_RESP:
xf_process_rail_appid_resp_event(xfi, chanman, event); xf_process_rail_appid_resp_event(xfi, channels, event);
break; break;
case RDP_EVENT_TYPE_RAIL_CHANNEL_LANGBARINFO: case RDP_EVENT_TYPE_RAIL_CHANNEL_LANGBARINFO:
xf_process_rail_langbarinfo_event(xfi, chanman, event); xf_process_rail_langbarinfo_event(xfi, channels, event);
break; break;
default: default:

82
client/X11/xfreerdp.c
View File

@ -74,6 +74,9 @@ struct thread_data
freerdp* instance; freerdp* instance;
}; };
int xf_process_client_args(rdpSettings* settings, const char* opt, const char* val, void* user_data);
int xf_process_plugin_args(rdpSettings* settings, const char* name, RDP_PLUGIN_DATA* plugin_data, void* user_data);
void xf_context_size(freerdp* instance, uint32* size) void xf_context_size(freerdp* instance, uint32* size)
{ {
*size = sizeof(xfContext); *size = sizeof(xfContext);
@ -81,7 +84,8 @@ void xf_context_size(freerdp* instance, uint32* size)
void xf_context_new(freerdp* instance, xfContext* context) void xf_context_new(freerdp* instance, xfContext* context)
{ {
context->channels = freerdp_channels_new(); rdpContext* _context = &context->_p;
_context->channels = freerdp_channels_new();
} }
void xf_context_free(freerdp* instance, xfContext* context) void xf_context_free(freerdp* instance, xfContext* context)
@ -527,10 +531,19 @@ boolean xf_pre_connect(freerdp* instance)
xfi = (xfInfo*) xzalloc(sizeof(xfInfo)); xfi = (xfInfo*) xzalloc(sizeof(xfInfo));
((xfContext*) instance->context)->xfi = xfi; ((xfContext*) instance->context)->xfi = xfi;
xfi->_context = instance->context;
xfi->context = (xfContext*) instance->context; xfi->context = (xfContext*) instance->context;
xfi->context->settings = instance->settings; xfi->context->settings = instance->settings;
xfi->instance = instance; xfi->instance = instance;
if (freerdp_parse_args(instance->settings, instance->context->argc, instance->context->argv,
xf_process_plugin_args, instance->context->channels, xf_process_client_args, xfi) < 0)
{
printf("failed to parse arguments.\n");
exit(0);
}
settings = instance->settings; settings = instance->settings;
bitmap_cache = settings->bitmap_cache; bitmap_cache = settings->bitmap_cache;
@ -559,7 +572,7 @@ boolean xf_pre_connect(freerdp* instance)
settings->order_support[NEG_ELLIPSE_SC_INDEX] = False; settings->order_support[NEG_ELLIPSE_SC_INDEX] = False;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = False; settings->order_support[NEG_ELLIPSE_CB_INDEX] = False;
freerdp_channels_pre_connect(xfi->context->channels, instance); freerdp_channels_pre_connect(xfi->_context->channels, instance);
xfi->display = XOpenDisplay(NULL); xfi->display = XOpenDisplay(NULL);
@ -623,11 +636,11 @@ boolean xf_post_connect(freerdp* instance)
xfInfo* xfi; xfInfo* xfi;
XGCValues gcv; XGCValues gcv;
rdpCache* cache; rdpCache* cache;
rdpChannels* chanman; rdpChannels* channels;
xfi = ((xfContext*) instance->context)->xfi; xfi = ((xfContext*) instance->context)->xfi;
cache = instance->context->cache; cache = instance->context->cache;
chanman = xfi->context->channels; channels = xfi->_context->channels;
if (xf_get_pixmap_info(xfi) != True) if (xf_get_pixmap_info(xfi) != True)
return False; return False;
@ -728,9 +741,9 @@ boolean xf_post_connect(freerdp* instance)
cache->bitmap->BitmapFree = (cbBitmapFree) xf_bitmap_free; cache->bitmap->BitmapFree = (cbBitmapFree) xf_bitmap_free;
offscreen_cache_register_callbacks(instance->update); offscreen_cache_register_callbacks(instance->update);
cache->offscreen->OffscreenBitmapSize = (cbOffscreenBitmapSize) xf_bitmap_size; cache->offscreen->BitmapSize = (cbBitmapSize) xf_bitmap_size;
cache->offscreen->OffscreenBitmapNew = (cbOffscreenBitmapNew) xf_offscreen_bitmap_new; cache->offscreen->BitmapNew = (cbBitmapNew) xf_offscreen_bitmap_new;
cache->offscreen->OffscreenBitmapFree = (cbOffscreenBitmapFree) xf_bitmap_free; cache->offscreen->BitmapFree = (cbBitmapFree) xf_bitmap_free;
cache->offscreen->SetSurface = (cbSetSurface) xf_set_surface; cache->offscreen->SetSurface = (cbSetSurface) xf_set_surface;
} }
@ -738,12 +751,12 @@ boolean xf_post_connect(freerdp* instance)
rail_register_update_callbacks(instance->context->rail, instance->update); rail_register_update_callbacks(instance->context->rail, instance->update);
xf_rail_register_callbacks(xfi, instance->context->rail); xf_rail_register_callbacks(xfi, instance->context->rail);
freerdp_channels_post_connect(chanman, instance); freerdp_channels_post_connect(channels, instance);
xf_tsmf_init(xfi, xv_port); xf_tsmf_init(xfi, xv_port);
if (xfi->remote_app != True) if (xfi->remote_app != True)
xf_cliprdr_init(xfi, chanman); xf_cliprdr_init(xfi, channels);
return True; return True;
} }
@ -758,7 +771,7 @@ boolean xf_authenticate(freerdp* instance, char** username, char** password, cha
return True; return True;
} }
int xf_process_ui_args(rdpSettings* settings, const char* opt, const char* val, void* user_data) int xf_process_client_args(rdpSettings* settings, const char* opt, const char* val, void* user_data)
{ {
int argc = 0; int argc = 0;
@ -798,10 +811,10 @@ int xf_process_ui_args(rdpSettings* settings, const char* opt, const char* val,
int xf_process_plugin_args(rdpSettings* settings, const char* name, RDP_PLUGIN_DATA* plugin_data, void* user_data) int xf_process_plugin_args(rdpSettings* settings, const char* name, RDP_PLUGIN_DATA* plugin_data, void* user_data)
{ {
rdpChannels* chanman = (rdpChannels*) user_data; rdpChannels* channels = (rdpChannels*) user_data;
printf("loading plugin %s\n", name); printf("loading plugin %s\n", name);
freerdp_channels_load_plugin(chanman, settings, name, plugin_data); freerdp_channels_load_plugin(channels, settings, name, plugin_data);
return 1; return 1;
} }
@ -870,14 +883,21 @@ void xf_window_free(xfInfo* xfi)
xfi->image = NULL; xfi->image = NULL;
} }
if (context->cache) if (context != NULL)
{ {
cache_free(context->cache); if (context->cache != NULL)
context->cache = NULL; {
cache_free(context->cache);
context->cache = NULL;
}
if (context->rail != NULL)
{
rail_free(context->rail);
context->rail = NULL;
}
} }
xfree(xfi->clrconv); xfree(xfi->clrconv);
rail_free(context->rail);
xf_tsmf_uninit(xfi); xf_tsmf_uninit(xfi);
xf_cliprdr_uninit(xfi); xf_cliprdr_uninit(xfi);
@ -902,28 +922,28 @@ int xfreerdp_run(freerdp* instance)
void* wfds[32]; void* wfds[32];
fd_set rfds_set; fd_set rfds_set;
fd_set wfds_set; fd_set wfds_set;
rdpChannels* chanman; rdpChannels* channels;
memset(rfds, 0, sizeof(rfds)); memset(rfds, 0, sizeof(rfds));
memset(wfds, 0, sizeof(wfds)); memset(wfds, 0, sizeof(wfds));
if (!instance->Connect(instance)) if (!freerdp_connect(instance))
return 0; return 0;
xfi = ((xfContext*) instance->context)->xfi; xfi = ((xfContext*) instance->context)->xfi;
chanman = ((xfContext*) instance->context)->channels; channels = instance->context->channels;
while (1) while (1)
{ {
rcount = 0; rcount = 0;
wcount = 0; wcount = 0;
if (instance->GetFileDescriptor(instance, rfds, &rcount, wfds, &wcount) != True) if (freerdp_get_fds(instance, rfds, &rcount, wfds, &wcount) != True)
{ {
printf("Failed to get FreeRDP file descriptor\n"); printf("Failed to get FreeRDP file descriptor\n");
break; break;
} }
if (freerdp_channels_get_fds(chanman, instance, rfds, &rcount, wfds, &wcount) != True) if (freerdp_channels_get_fds(channels, instance, rfds, &rcount, wfds, &wcount) != True)
{ {
printf("Failed to get channel manager file descriptor\n"); printf("Failed to get channel manager file descriptor\n");
break; break;
@ -964,7 +984,7 @@ int xfreerdp_run(freerdp* instance)
} }
} }
if (instance->CheckFileDescriptor(instance) != True) if (freerdp_check_fds(instance) != True)
{ {
printf("Failed to check FreeRDP file descriptor\n"); printf("Failed to check FreeRDP file descriptor\n");
break; break;
@ -974,17 +994,17 @@ int xfreerdp_run(freerdp* instance)
printf("Failed to check xfreerdp file descriptor\n"); printf("Failed to check xfreerdp file descriptor\n");
break; break;
} }
if (freerdp_channels_check_fds(chanman, instance) != True) if (freerdp_channels_check_fds(channels, instance) != True)
{ {
printf("Failed to check channel manager file descriptor\n"); printf("Failed to check channel manager file descriptor\n");
break; break;
} }
xf_process_channel_event(chanman, instance); xf_process_channel_event(channels, instance);
} }
freerdp_channels_close(chanman, instance); freerdp_channels_close(channels, instance);
freerdp_channels_free(chanman); freerdp_channels_free(channels);
instance->Disconnect(instance); freerdp_disconnect(instance);
gdi_free(instance); gdi_free(instance);
freerdp_free(instance); freerdp_free(instance);
xf_free(xfi); xf_free(xfi);
@ -1015,7 +1035,6 @@ int main(int argc, char* argv[])
{ {
pthread_t thread; pthread_t thread;
freerdp* instance; freerdp* instance;
xfContext* context;
struct thread_data* data; struct thread_data* data;
freerdp_handle_signals(); freerdp_handle_signals();
@ -1037,12 +1056,9 @@ int main(int argc, char* argv[])
instance->ContextFree = (pcContextFree) xf_context_free; instance->ContextFree = (pcContextFree) xf_context_free;
freerdp_context_new(instance); freerdp_context_new(instance);
instance->context->argc = argc;
instance->context->argv = argv;
instance->settings->sw_gdi = False; instance->settings->sw_gdi = False;
context = (xfContext*) instance->context;
if (freerdp_parse_args(instance->settings, argc, argv,
xf_process_plugin_args, context->channels, xf_process_ui_args, NULL) < 0)
return 1;
data = (struct thread_data*) xzalloc(sizeof(struct thread_data)); data = (struct thread_data*) xzalloc(sizeof(struct thread_data));
data->instance = instance; data->instance = instance;

3
client/X11/xfreerdp.h
View File

@ -63,7 +63,7 @@ struct xf_context
rdpContext _p; rdpContext _p;
xfInfo* xfi; xfInfo* xfi;
rdpChannels* channels; //rdpChannels* channels;
rdpSettings* settings; rdpSettings* settings;
}; };
typedef struct xf_context xfContext; typedef struct xf_context xfContext;
@ -72,6 +72,7 @@ struct xf_info
{ {
freerdp* instance; freerdp* instance;
xfContext* context; xfContext* context;
rdpContext* _context;
GC gc; GC gc;
int bpp; int bpp;

48
client/test/freerdp.c
View File

@ -50,7 +50,7 @@ struct tf_context
rdpContext _p; rdpContext _p;
tfInfo* tfi; tfInfo* tfi;
rdpChannels* chanman; rdpChannels* channels;
}; };
typedef struct tf_context tfContext; typedef struct tf_context tfContext;
@ -72,7 +72,7 @@ void tf_context_size(freerdp* instance, uint32* size)
void tf_context_new(freerdp* instance, tfContext* context) void tf_context_new(freerdp* instance, tfContext* context)
{ {
context->chanman = freerdp_channels_new(); context->channels = freerdp_channels_new();
} }
void tf_context_free(freerdp* instance, tfContext* context) void tf_context_free(freerdp* instance, tfContext* context)
@ -101,15 +101,15 @@ int tf_receive_channel_data(freerdp* instance, int channelId, uint8* data, int s
int tf_process_plugin_args(rdpSettings* settings, const char* name, RDP_PLUGIN_DATA* plugin_data, void* user_data) int tf_process_plugin_args(rdpSettings* settings, const char* name, RDP_PLUGIN_DATA* plugin_data, void* user_data)
{ {
rdpChannels* chanman = (rdpChannels*) user_data; rdpChannels* channels = (rdpChannels*) user_data;
printf("Load plugin %s\n", name); printf("Load plugin %s\n", name);
freerdp_channels_load_plugin(chanman, settings, name, plugin_data); freerdp_channels_load_plugin(channels, settings, name, plugin_data);
return 1; return 1;
} }
void tf_process_cb_sync_event(rdpChannels* chanman, freerdp* instance) void tf_process_cb_sync_event(rdpChannels* channels, freerdp* instance)
{ {
RDP_EVENT* event; RDP_EVENT* event;
RDP_CB_FORMAT_LIST_EVENT* format_list_event; RDP_CB_FORMAT_LIST_EVENT* format_list_event;
@ -119,21 +119,21 @@ void tf_process_cb_sync_event(rdpChannels* chanman, freerdp* instance)
format_list_event = (RDP_CB_FORMAT_LIST_EVENT*)event; format_list_event = (RDP_CB_FORMAT_LIST_EVENT*)event;
format_list_event->num_formats = 0; format_list_event->num_formats = 0;
freerdp_channels_send_event(chanman, event); freerdp_channels_send_event(channels, event);
} }
void tf_process_channel_event(rdpChannels* chanman, freerdp* instance) void tf_process_channel_event(rdpChannels* channels, freerdp* instance)
{ {
RDP_EVENT* event; RDP_EVENT* event;
event = freerdp_channels_pop_event(chanman); event = freerdp_channels_pop_event(channels);
if (event) if (event)
{ {
switch (event->event_type) switch (event->event_type)
{ {
case RDP_EVENT_TYPE_CB_SYNC: case RDP_EVENT_TYPE_CB_SYNC:
tf_process_cb_sync_event(chanman, instance); tf_process_cb_sync_event(channels, instance);
break; break;
default: default:
printf("tf_process_channel_event: unknown event type %d\n", event->event_type); printf("tf_process_channel_event: unknown event type %d\n", event->event_type);
@ -179,7 +179,7 @@ boolean tf_pre_connect(freerdp* instance)
settings->order_support[NEG_ELLIPSE_SC_INDEX] = True; settings->order_support[NEG_ELLIPSE_SC_INDEX] = True;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = True; settings->order_support[NEG_ELLIPSE_CB_INDEX] = True;
freerdp_channels_pre_connect(context->chanman, instance); freerdp_channels_pre_connect(context->channels, instance);
return True; return True;
} }
@ -197,7 +197,7 @@ boolean tf_post_connect(freerdp* instance)
instance->update->BeginPaint = tf_begin_paint; instance->update->BeginPaint = tf_begin_paint;
instance->update->EndPaint = tf_end_paint; instance->update->EndPaint = tf_end_paint;
freerdp_channels_post_connect(context->chanman, instance); freerdp_channels_post_connect(context->channels, instance);
return True; return True;
} }
@ -214,27 +214,27 @@ int tfreerdp_run(freerdp* instance)
fd_set rfds_set; fd_set rfds_set;
fd_set wfds_set; fd_set wfds_set;
tfContext* context; tfContext* context;
rdpChannels* chanman; rdpChannels* channels;
memset(rfds, 0, sizeof(rfds)); memset(rfds, 0, sizeof(rfds));
memset(wfds, 0, sizeof(wfds)); memset(wfds, 0, sizeof(wfds));
context = (tfContext*) instance->context; context = (tfContext*) instance->context;
chanman = context->chanman; channels = context->channels;
instance->Connect(instance); freerdp_connect(instance);
while (1) while (1)
{ {
rcount = 0; rcount = 0;
wcount = 0; wcount = 0;
if (instance->GetFileDescriptor(instance, rfds, &rcount, wfds, &wcount) != True) if (freerdp_get_fds(instance, rfds, &rcount, wfds, &wcount) != True)
{ {
printf("Failed to get FreeRDP file descriptor\n"); printf("Failed to get FreeRDP file descriptor\n");
break; break;
} }
if (freerdp_channels_get_fds(chanman, instance, rfds, &rcount, wfds, &wcount) != True) if (freerdp_channels_get_fds(channels, instance, rfds, &rcount, wfds, &wcount) != True)
{ {
printf("Failed to get channel manager file descriptor\n"); printf("Failed to get channel manager file descriptor\n");
break; break;
@ -269,21 +269,21 @@ int tfreerdp_run(freerdp* instance)
} }
} }
if (instance->CheckFileDescriptor(instance) != True) if (freerdp_check_fds(instance) != True)
{ {
printf("Failed to check FreeRDP file descriptor\n"); printf("Failed to check FreeRDP file descriptor\n");
break; break;
} }
if (freerdp_channels_check_fds(chanman, instance) != True) if (freerdp_channels_check_fds(channels, instance) != True)
{ {
printf("Failed to check channel manager file descriptor\n"); printf("Failed to check channel manager file descriptor\n");
break; break;
} }
tf_process_channel_event(chanman, instance); tf_process_channel_event(channels, instance);
} }
freerdp_channels_close(chanman, instance); freerdp_channels_close(channels, instance);
freerdp_channels_free(chanman); freerdp_channels_free(channels);
freerdp_free(instance); freerdp_free(instance);
return 0; return 0;
@ -314,7 +314,7 @@ int main(int argc, char* argv[])
freerdp* instance; freerdp* instance;
tfContext* context; tfContext* context;
struct thread_data* data; struct thread_data* data;
rdpChannels* chanman; rdpChannels* channels;
freerdp_channels_global_init(); freerdp_channels_global_init();
@ -331,9 +331,9 @@ int main(int argc, char* argv[])
freerdp_context_new(instance); freerdp_context_new(instance);
context = (tfContext*) instance->context; context = (tfContext*) instance->context;
chanman = context->chanman; channels = context->channels;
freerdp_parse_args(instance->settings, argc, argv, tf_process_plugin_args, chanman, NULL, NULL); freerdp_parse_args(instance->settings, argc, argv, tf_process_plugin_args, channels, NULL, NULL);
data = (struct thread_data*) xzalloc(sizeof(struct thread_data)); data = (struct thread_data*) xzalloc(sizeof(struct thread_data));
data->instance = instance; data->instance = instance;

8
include/freerdp/cache/bitmap.h vendored
View File

@ -29,6 +29,10 @@
typedef struct _BITMAP_V2_CELL BITMAP_V2_CELL; typedef struct _BITMAP_V2_CELL BITMAP_V2_CELL;
typedef struct rdp_bitmap_cache rdpBitmapCache; typedef struct rdp_bitmap_cache rdpBitmapCache;
typedef void (*cbBitmapSize)(rdpUpdate* update, uint32* size);
typedef void (*cbBitmapNew)(rdpUpdate* update, rdpBitmap* bitmap);
typedef void (*cbBitmapFree)(rdpUpdate* update, rdpBitmap* bitmap);
#include <freerdp/cache/cache.h> #include <freerdp/cache/cache.h>
struct _BITMAP_V2_CELL struct _BITMAP_V2_CELL
@ -37,10 +41,6 @@ struct _BITMAP_V2_CELL
rdpBitmap** entries; rdpBitmap** entries;
}; };
typedef void (*cbBitmapSize)(rdpUpdate* update, uint32* size);
typedef void (*cbBitmapNew)(rdpUpdate* update, rdpBitmap* bitmap);
typedef void (*cbBitmapFree)(rdpUpdate* update, rdpBitmap* bitmap);
struct rdp_bitmap_cache struct rdp_bitmap_cache
{ {
pcMemBlt MemBlt; pcMemBlt MemBlt;

4
include/freerdp/cache/brush.h vendored
View File

@ -41,8 +41,8 @@ struct rdp_brush
}; };
typedef struct rdp_brush rdpBrushCache; typedef struct rdp_brush rdpBrushCache;
FREERDP_API void* brush_get(rdpBrushCache* brush, uint8 index, uint8* bpp); FREERDP_API void* brush_cache_get(rdpBrushCache* brush, uint8 index, uint8* bpp);
FREERDP_API void brush_put(rdpBrushCache* brush, uint8 index, void* entry, uint8 bpp); FREERDP_API void brush_cache_put(rdpBrushCache* brush, uint8 index, void* entry, uint8 bpp);
FREERDP_API rdpBrushCache* brush_cache_new(rdpSettings* settings); FREERDP_API rdpBrushCache* brush_cache_new(rdpSettings* settings);
FREERDP_API void brush_cache_free(rdpBrushCache* brush); FREERDP_API void brush_cache_free(rdpBrushCache* brush);

13
include/freerdp/cache/offscreen.h vendored
View File

@ -27,20 +27,15 @@
#include <freerdp/utils/stream.h> #include <freerdp/utils/stream.h>
typedef struct rdp_offscreen_cache rdpOffscreenCache; typedef struct rdp_offscreen_cache rdpOffscreenCache;
typedef void (*cbSetSurface)(rdpUpdate* update, rdpBitmap* bitmap, boolean primary);
#include <freerdp/cache/cache.h> #include <freerdp/cache/cache.h>
typedef void (*cbOffscreenBitmapSize)(rdpUpdate* update, uint32* size);
typedef void (*cbOffscreenBitmapNew)(rdpUpdate* update, rdpBitmap* bitmap);
typedef void (*cbOffscreenBitmapFree)(rdpUpdate* update, rdpBitmap* bitmap);
typedef void (*cbSetSurface)(rdpUpdate* update, rdpBitmap* bitmap, boolean primary);
struct rdp_offscreen_cache struct rdp_offscreen_cache
{ {
cbOffscreenBitmapSize OffscreenBitmapSize; cbBitmapSize BitmapSize;
cbOffscreenBitmapNew OffscreenBitmapNew; cbBitmapNew BitmapNew;
cbOffscreenBitmapFree OffscreenBitmapFree; cbBitmapFree BitmapFree;
cbSetSurface SetSurface; cbSetSurface SetSurface;
uint16 currentSurface; uint16 currentSurface;

9
include/freerdp/channels/channels.h
View File

@ -18,18 +18,17 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef __FREERDP_CHANMAN_H #ifndef __FREERDP_CHANNELS_H
#define __FREERDP_CHANMAN_H #define __FREERDP_CHANNELS_H
#include <freerdp/api.h> #include <freerdp/api.h>
#include <freerdp/types.h> #include <freerdp/types.h>
#include <freerdp/freerdp.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef struct rdp_channels rdpChannels;
FREERDP_API int freerdp_channels_global_init(void); FREERDP_API int freerdp_channels_global_init(void);
FREERDP_API int freerdp_channels_global_uninit(void); FREERDP_API int freerdp_channels_global_uninit(void);
FREERDP_API rdpChannels* freerdp_channels_new(void); FREERDP_API rdpChannels* freerdp_channels_new(void);
@ -51,4 +50,4 @@ FREERDP_API void freerdp_channels_close(rdpChannels* channels, freerdp* instance
} }
#endif #endif
#endif #endif /* __FREERDP_CHANNELS_H */

39
include/freerdp/freerdp.h
View File

@ -24,6 +24,8 @@ typedef struct rdp_rdp rdpRdp;
typedef struct rdp_gdi rdpGdi; typedef struct rdp_gdi rdpGdi;
typedef struct rdp_rail rdpRail; typedef struct rdp_rail rdpRail;
typedef struct rdp_cache rdpCache; typedef struct rdp_cache rdpCache;
typedef struct rdp_channels rdpChannels;
typedef struct rdp_freerdp freerdp; typedef struct rdp_freerdp freerdp;
typedef struct rdp_context rdpContext; typedef struct rdp_context rdpContext;
@ -39,31 +41,31 @@ typedef struct rdp_context rdpContext;
extern "C" { extern "C" {
#endif #endif
FREERDP_API boolean freerdp_global_init();
FREERDP_API void freerdp_global_finish();
typedef boolean (*pcConnect)(freerdp* instance);
typedef boolean (*pcPreConnect)(freerdp* instance);
typedef boolean (*pcPostConnect)(freerdp* instance);
typedef boolean (*pcAuthenticate)(freerdp* instance, char** username, char** password, char** domain);
typedef boolean (*pcGetFileDescriptor)(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount);
typedef boolean (*pcCheckFileDescriptor)(freerdp* instance);
typedef int (*pcSendChannelData)(freerdp* instance, int channelId, uint8* data, int size);
typedef int (*pcReceiveChannelData)(freerdp* instance, int channelId, uint8* data, int size, int flags, int total_size);
typedef void (*pcDisconnect)(freerdp* instance);
typedef void (*pcContextSize)(freerdp* instance, uint32* size); typedef void (*pcContextSize)(freerdp* instance, uint32* size);
typedef void (*pcContextNew)(freerdp* instance, rdpContext* context); typedef void (*pcContextNew)(freerdp* instance, rdpContext* context);
typedef void (*pcContextFree)(freerdp* instance, rdpContext* context); typedef void (*pcContextFree)(freerdp* instance, rdpContext* context);
typedef boolean (*pcPreConnect)(freerdp* instance);
typedef boolean (*pcPostConnect)(freerdp* instance);
typedef boolean (*pcAuthenticate)(freerdp* instance, char** username, char** password, char** domain);
typedef int (*pcSendChannelData)(freerdp* instance, int channelId, uint8* data, int size);
typedef int (*pcReceiveChannelData)(freerdp* instance, int channelId, uint8* data, int size, int flags, int total_size);
struct rdp_context struct rdp_context
{ {
freerdp* instance; freerdp* instance;
int argc;
char** argv;
rdpRdp* rdp; rdpRdp* rdp;
rdpGdi* gdi; rdpGdi* gdi;
rdpRail* rail; rdpRail* rail;
rdpCache* cache; rdpCache* cache;
rdpChannels* channels;
void* reserved[32 - 6];
}; };
struct rdp_freerdp struct rdp_freerdp
@ -78,20 +80,23 @@ struct rdp_freerdp
pcContextNew ContextNew; pcContextNew ContextNew;
pcContextFree ContextFree; pcContextFree ContextFree;
pcConnect Connect;
pcPreConnect PreConnect; pcPreConnect PreConnect;
pcPostConnect PostConnect; pcPostConnect PostConnect;
pcAuthenticate Authenticate; pcAuthenticate Authenticate;
pcGetFileDescriptor GetFileDescriptor;
pcCheckFileDescriptor CheckFileDescriptor;
pcSendChannelData SendChannelData; pcSendChannelData SendChannelData;
pcReceiveChannelData ReceiveChannelData; pcReceiveChannelData ReceiveChannelData;
pcDisconnect Disconnect;
}; };
FREERDP_API void freerdp_context_new(freerdp* instance); FREERDP_API void freerdp_context_new(freerdp* instance);
FREERDP_API void freerdp_context_free(freerdp* instance); FREERDP_API void freerdp_context_free(freerdp* instance);
FREERDP_API boolean freerdp_connect(freerdp* instance);
FREERDP_API boolean freerdp_disconnect(freerdp* instance);
FREERDP_API boolean freerdp_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds, int* wcount);
FREERDP_API boolean freerdp_check_fds(freerdp* instance);
FREERDP_API freerdp* freerdp_new(); FREERDP_API freerdp* freerdp_new();
FREERDP_API void freerdp_free(freerdp* instance); FREERDP_API void freerdp_free(freerdp* instance);

12
include/freerdp/update.h
View File

@ -1047,6 +1047,7 @@ typedef void (*pcDesktopResize)(rdpUpdate* update);
typedef void (*pcBitmap)(rdpUpdate* update, BITMAP_UPDATE* bitmap); typedef void (*pcBitmap)(rdpUpdate* update, BITMAP_UPDATE* bitmap);
typedef void (*pcPalette)(rdpUpdate* update, PALETTE_UPDATE* palette); typedef void (*pcPalette)(rdpUpdate* update, PALETTE_UPDATE* palette);
typedef void (*pcPlaySound)(rdpUpdate* update, PLAY_SOUND_UPDATE* play_sound); typedef void (*pcPlaySound)(rdpUpdate* update, PLAY_SOUND_UPDATE* play_sound);
typedef void (*pcPointerPosition)(rdpUpdate* update, POINTER_POSITION_UPDATE* pointer_position); typedef void (*pcPointerPosition)(rdpUpdate* update, POINTER_POSITION_UPDATE* pointer_position);
typedef void (*pcPointerSystem)(rdpUpdate* update, POINTER_SYSTEM_UPDATE* pointer_system); typedef void (*pcPointerSystem)(rdpUpdate* update, POINTER_SYSTEM_UPDATE* pointer_system);
typedef void (*pcPointerColor)(rdpUpdate* update, POINTER_COLOR_UPDATE* pointer_color); typedef void (*pcPointerColor)(rdpUpdate* update, POINTER_COLOR_UPDATE* pointer_color);
@ -1117,10 +1118,6 @@ struct rdp_update
{ {
rdpContext* context; rdpContext* context;
boolean dump_rfx;
boolean play_rfx;
rdpPcap* pcap_rfx;
pcBeginPaint BeginPaint; pcBeginPaint BeginPaint;
pcEndPaint EndPaint; pcEndPaint EndPaint;
pcSetBounds SetBounds; pcSetBounds SetBounds;
@ -1158,7 +1155,6 @@ struct rdp_update
pcEllipseSC EllipseSC; pcEllipseSC EllipseSC;
pcEllipseCB EllipseCB; pcEllipseCB EllipseCB;
boolean glyph_v2;
pcCacheBitmap CacheBitmap; pcCacheBitmap CacheBitmap;
pcCacheBitmapV2 CacheBitmapV2; pcCacheBitmapV2 CacheBitmapV2;
pcCacheBitmapV3 CacheBitmapV3; pcCacheBitmapV3 CacheBitmapV3;
@ -1196,6 +1192,12 @@ struct rdp_update
pcBitmapDecompress BitmapDecompress; pcBitmapDecompress BitmapDecompress;
boolean glyph_v2;
boolean dump_rfx;
boolean play_rfx;
rdpPcap* pcap_rfx;
BITMAP_UPDATE bitmap_update; BITMAP_UPDATE bitmap_update;
PALETTE_UPDATE palette_update; PALETTE_UPDATE palette_update;
PLAY_SOUND_UPDATE play_sound; PLAY_SOUND_UPDATE play_sound;

4
libfreerdp-cache/brush.c
View File

@ -22,7 +22,7 @@
#include <freerdp/cache/brush.h> #include <freerdp/cache/brush.h>
void* brush_get(rdpBrushCache* brush, uint8 index, uint8* bpp) void* brush_cache_get(rdpBrushCache* brush, uint8 index, uint8* bpp)
{ {
void* entry; void* entry;
@ -58,7 +58,7 @@ void* brush_get(rdpBrushCache* brush, uint8 index, uint8* bpp)
return entry; return entry;
} }
void brush_put(rdpBrushCache* brush, uint8 index, void* entry, uint8 bpp) void brush_cache_put(rdpBrushCache* brush, uint8 index, void* entry, uint8 bpp)
{ {
if (bpp == 1) if (bpp == 1)
{ {

8
libfreerdp-cache/offscreen.c
View File

@ -29,18 +29,18 @@ void update_gdi_create_offscreen_bitmap(rdpUpdate* update, CREATE_OFFSCREEN_BITM
uint32 size = sizeof(rdpBitmap); uint32 size = sizeof(rdpBitmap);
rdpCache* cache = update->context->cache; rdpCache* cache = update->context->cache;
IFCALL(cache->offscreen->OffscreenBitmapSize, update, &size); IFCALL(cache->offscreen->BitmapSize, update, &size);
bitmap = (rdpBitmap*) xzalloc(size); bitmap = (rdpBitmap*) xzalloc(size);
bitmap->width = create_offscreen_bitmap->cx; bitmap->width = create_offscreen_bitmap->cx;
bitmap->height = create_offscreen_bitmap->cy; bitmap->height = create_offscreen_bitmap->cy;
IFCALL(cache->offscreen->OffscreenBitmapNew, update, bitmap); IFCALL(cache->offscreen->BitmapNew, update, bitmap);
prevBitmap = offscreen_cache_get(cache->offscreen, create_offscreen_bitmap->id); prevBitmap = offscreen_cache_get(cache->offscreen, create_offscreen_bitmap->id);
if (prevBitmap != NULL) if (prevBitmap != NULL)
{ {
IFCALL(cache->offscreen->OffscreenBitmapFree, update, prevBitmap); IFCALL(cache->offscreen->BitmapFree, update, prevBitmap);
bitmap_free(prevBitmap); bitmap_free(prevBitmap);
} }
@ -142,7 +142,7 @@ void offscreen_cache_free(rdpOffscreenCache* offscreen_cache)
if (bitmap != NULL) if (bitmap != NULL)
{ {
IFCALL(offscreen_cache->OffscreenBitmapFree, offscreen_cache->update, bitmap); IFCALL(offscreen_cache->BitmapFree, offscreen_cache->update, bitmap);
bitmap_free(bitmap); bitmap_free(bitmap);
} }
} }

8
libfreerdp-channels/libchannels.c
View File

@ -825,9 +825,9 @@ FREERDP_API int freerdp_channels_send_event(rdpChannels* chan_man, RDP_EVENT* ev
*/ */
static void freerdp_channels_process_sync(rdpChannels* chan_man, freerdp* instance) static void freerdp_channels_process_sync(rdpChannels* chan_man, freerdp* instance)
{ {
struct channel_data* lchan_data;
rdpChannel* lrdp_chan; rdpChannel* lrdp_chan;
struct sync_data* item; struct sync_data* item;
struct channel_data* lchan_data;
while (chan_man->sync_data_list->head != NULL) while (chan_man->sync_data_list->head != NULL)
{ {
@ -838,10 +838,10 @@ static void freerdp_channels_process_sync(rdpChannels* chan_man, freerdp* instan
lchan_data = chan_man->chans + item->index; lchan_data = chan_man->chans + item->index;
lrdp_chan = freerdp_channels_find_channel_by_name(chan_man, instance->settings, lrdp_chan = freerdp_channels_find_channel_by_name(chan_man, instance->settings,
lchan_data->name, &item->index); lchan_data->name, &item->index);
if (lrdp_chan != NULL) if (lrdp_chan != NULL)
{ instance->SendChannelData(instance, lrdp_chan->channel_id, item->data, item->data_length);
IFCALL(instance->SendChannelData, instance, lrdp_chan->channel_id, item->data, item->data_length);
}
if (lchan_data->open_event_proc != 0) if (lchan_data->open_event_proc != 0)
{ {
lchan_data->open_event_proc(lchan_data->open_handle, lchan_data->open_event_proc(lchan_data->open_handle,

8
libfreerdp-core/freerdp.c
View File

@ -113,12 +113,14 @@ static int freerdp_send_channel_data(freerdp* instance, int channel_id, uint8* d
return rdp_send_channel_data(instance->context->rdp, channel_id, data, size); return rdp_send_channel_data(instance->context->rdp, channel_id, data, size);
} }
void freerdp_disconnect(freerdp* instance) boolean freerdp_disconnect(freerdp* instance)
{ {
rdpRdp* rdp; rdpRdp* rdp;
rdp = instance->context->rdp; rdp = instance->context->rdp;
transport_disconnect(rdp->transport); transport_disconnect(rdp->transport);
return True;
} }
void freerdp_context_new(freerdp* instance) void freerdp_context_new(freerdp* instance)
@ -157,11 +159,7 @@ freerdp* freerdp_new()
if (instance != NULL) if (instance != NULL)
{ {
instance->Connect = freerdp_connect;
instance->GetFileDescriptor = freerdp_get_fds;
instance->CheckFileDescriptor = freerdp_check_fds;
instance->SendChannelData = freerdp_send_channel_data; instance->SendChannelData = freerdp_send_channel_data;
instance->Disconnect = freerdp_disconnect;
} }
return instance; return instance;

10
libfreerdp-gdi/gdi.c
View File

@ -558,7 +558,7 @@ void gdi_patblt(rdpUpdate* update, PATBLT_ORDER* patblt)
if (brush->style & CACHED_BRUSH) if (brush->style & CACHED_BRUSH)
{ {
brush->data = brush_get(cache->brush, brush->index, &brush->bpp); brush->data = brush_cache_get(cache->brush, brush->index, &brush->bpp);
brush->style = GDI_BS_PATTERN; brush->style = GDI_BS_PATTERN;
} }
@ -873,7 +873,7 @@ void gdi_cache_glyph_v2(rdpUpdate* update, CACHE_GLYPH_V2_ORDER* cache_glyph_v2)
void gdi_cache_brush(rdpUpdate* update, CACHE_BRUSH_ORDER* cache_brush) void gdi_cache_brush(rdpUpdate* update, CACHE_BRUSH_ORDER* cache_brush)
{ {
rdpCache* cache = update->context->cache; rdpCache* cache = update->context->cache;
brush_put(cache->brush, cache_brush->index, cache_brush->data, cache_brush->bpp); brush_cache_put(cache->brush, cache_brush->index, cache_brush->data, cache_brush->bpp);
} }
int tilenum = 0; int tilenum = 0;
@ -1191,9 +1191,9 @@ int gdi_init(freerdp* instance, uint32 flags, uint8* buffer)
cache->bitmap->BitmapFree = (cbBitmapFree) gdi_bitmap_free; cache->bitmap->BitmapFree = (cbBitmapFree) gdi_bitmap_free;
offscreen_cache_register_callbacks(instance->update); offscreen_cache_register_callbacks(instance->update);
cache->offscreen->OffscreenBitmapSize = (cbOffscreenBitmapSize) gdi_bitmap_size; cache->offscreen->BitmapSize = (cbBitmapSize) gdi_bitmap_size;
cache->offscreen->OffscreenBitmapNew = (cbOffscreenBitmapNew) gdi_offscreen_bitmap_new; cache->offscreen->BitmapNew = (cbBitmapNew) gdi_offscreen_bitmap_new;
cache->offscreen->OffscreenBitmapFree = (cbOffscreenBitmapFree) gdi_bitmap_free; cache->offscreen->BitmapFree = (cbBitmapFree) gdi_bitmap_free;
cache->offscreen->SetSurface = (cbSetSurface) gdi_set_surface; cache->offscreen->SetSurface = (cbSetSurface) gdi_set_surface;
gdi->rfx_context = rfx_context_new(); gdi->rfx_context = rfx_context_new();