Memsys *memsys_new(void)
{
Memsys *sys = (Memsys *) calloc (1, sizeof (Memsys));
if(SIM_MODE==SIM_MODE_A){
sys->dcache = cache_new(DCACHE_SIZE, DCACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
}
if(SIM_MODE==SIM_MODE_B){
sys->dcache = cache_new(DCACHE_SIZE, DCACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
sys->icache = cache_new(ICACHE_SIZE, ICACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
sys->l2cache = cache_new(L2CACHE_SIZE, L2CACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
sys->dram = dram_new();
}
if(SIM_MODE==SIM_MODE_C){
sys->dcache = cache_new(DCACHE_SIZE, DCACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
sys->icache = cache_new(ICACHE_SIZE, ICACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
sys->l2cache = cache_new(L2CACHE_SIZE, L2CACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
sys->dram = dram_new();
}
if( (SIM_MODE==SIM_MODE_D) || (SIM_MODE==SIM_MODE_E)) {
sys->l2cache = cache_new(L2CACHE_SIZE, L2CACHE_ASSOC, CACHE_LINESIZE, L2CACHE_REPL);
sys->dram = dram_new();
uns ii;
for(ii=0; ii<NUM_CORES; ii++){
sys->dcache_coreid[ii] = cache_new(DCACHE_SIZE, DCACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
sys->icache_coreid[ii] = cache_new(ICACHE_SIZE, ICACHE_ASSOC, CACHE_LINESIZE, REPL_POLICY);
}
}
return sys;
}
int main()
{
fillArray(test_array, 4, 128);
cache = cache_new(CACHE_SIZE_IN_BLOCKS, block_size, 1, CACHE_REPLACEMENTPOLICY_LRU);
print_stats(sumA(test_array, 4, 128));
cache = cache_new(CACHE_SIZE_IN_BLOCKS, block_size, 1, CACHE_REPLACEMENTPOLICY_LRU);
print_stats(sumB(test_array, 4, 128));
cache = cache_new(CACHE_SIZE_IN_BLOCKS, block_size, 1, CACHE_REPLACEMENTPOLICY_LRU);
print_stats(sumC(test_array, 4, 128));
}
static BOOL android_post_connect(freerdp* instance)
{
UINT32 gdi_flags;
rdpSettings *settings = instance->settings;
DEBUG_ANDROID("android_post_connect");
assert(instance);
assert(settings);
freerdp_callback("OnSettingsChanged", "(IIII)V", instance,
settings->DesktopWidth, settings->DesktopHeight,
settings->ColorDepth);
instance->context->cache = cache_new(settings);
if (instance->settings->ColorDepth > 16)
gdi_flags = CLRBUF_32BPP | CLRCONV_ALPHA | CLRCONV_INVERT;
else
gdi_flags = CLRBUF_16BPP;
gdi_init(instance, gdi_flags, NULL);
instance->update->BeginPaint = android_begin_paint;
instance->update->EndPaint = android_end_paint;
instance->update->DesktopResize = android_desktop_resize;
freerdp_channels_post_connect(instance->context->channels, instance);
freerdp_callback("OnConnectionSuccess", "(I)V", instance);
return TRUE;
}
static boolean remmina_rdp_pre_connect(freerdp* instance)
{
rfContext* rfi;
rdpSettings* settings;
RemminaProtocolWidget* gp;
rfi = (rfContext*) instance->context;
settings = instance->settings;
gp = rfi->protocol_widget;
settings->bitmap_cache = True;
settings->offscreen_bitmap_cache = True;
settings->order_support[NEG_DSTBLT_INDEX] = True;
settings->order_support[NEG_PATBLT_INDEX] = True;
settings->order_support[NEG_SCRBLT_INDEX] = True;
settings->order_support[NEG_OPAQUE_RECT_INDEX] = True;
settings->order_support[NEG_DRAWNINEGRID_INDEX] = False;
settings->order_support[NEG_MULTIDSTBLT_INDEX] = False;
settings->order_support[NEG_MULTIPATBLT_INDEX] = False;
settings->order_support[NEG_MULTISCRBLT_INDEX] = False;
settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = True;
settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = False;
settings->order_support[NEG_LINETO_INDEX] = True;
settings->order_support[NEG_POLYLINE_INDEX] = True;
settings->order_support[NEG_MEMBLT_INDEX] = True;
settings->order_support[NEG_MEM3BLT_INDEX] = False;
settings->order_support[NEG_MEMBLT_V2_INDEX] = True;
settings->order_support[NEG_MEM3BLT_V2_INDEX] = False;
settings->order_support[NEG_SAVEBITMAP_INDEX] = False;
settings->order_support[NEG_GLYPH_INDEX_INDEX] = True;
settings->order_support[NEG_FAST_INDEX_INDEX] = True;
settings->order_support[NEG_FAST_GLYPH_INDEX] = False;
settings->order_support[NEG_POLYGON_SC_INDEX] = False;
settings->order_support[NEG_POLYGON_CB_INDEX] = False;
settings->order_support[NEG_ELLIPSE_SC_INDEX] = False;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = False;
if (settings->rfx_codec == True)
{
settings->frame_acknowledge = False;
settings->large_pointer = True;
settings->performance_flags = PERF_FLAG_NONE;
rfi->rfx_context = rfx_context_new();
rfx_context_set_cpu_opt(rfi->rfx_context, CPU_SSE2);
}
freerdp_channels_pre_connect(rfi->channels, instance);
rfi->clrconv = xnew(CLRCONV);
rfi->clrconv->alpha = true;
rfi->clrconv->invert = false;
rfi->clrconv->rgb555 = false;
rfi->clrconv->palette = xnew(rdpPalette);
instance->context->cache = cache_new(instance->settings);
return True;
}
BOOL android_post_connect(freerdp* instance)
{
DEBUG_ANDROID("android_post_connect");
freerdp_callback("OnSettingsChanged", "(IIII)V", instance,
instance->settings->DesktopWidth, instance->settings->DesktopHeight,
instance->settings->ColorDepth);
instance->context->cache = cache_new(instance->settings);
gdi_init(instance, CLRCONV_ALPHA | ((instance->settings->ColorDepth > 16) ? CLRBUF_32BPP : CLRBUF_16BPP), NULL);
instance->update->BeginPaint = android_begin_paint;
instance->update->EndPaint = android_end_paint;
instance->update->DesktopResize = android_desktop_resize;
android_cliprdr_init(instance);
freerdp_channels_post_connect(instance->context->channels, instance);
// send notifications
freerdp_callback("OnConnectionSuccess", "(I)V", instance);
return TRUE;
}
static BOOL remmina_rdp_pre_connect(freerdp* instance)
{
rfContext* rfi;
ALIGN64 rdpSettings* settings;
RemminaProtocolWidget* gp;
rdpChannels *channels;
rfi = (rfContext*) instance->context;
settings = instance->settings;
gp = rfi->protocol_widget;
channels = instance->context->channels;
settings->BitmapCacheEnabled = True;
settings->OffscreenSupportLevel = True;
settings->OrderSupport[NEG_DSTBLT_INDEX] = True;
settings->OrderSupport[NEG_PATBLT_INDEX] = True;
settings->OrderSupport[NEG_SCRBLT_INDEX] = True;
settings->OrderSupport[NEG_OPAQUE_RECT_INDEX] = True;
settings->OrderSupport[NEG_DRAWNINEGRID_INDEX] = False;
settings->OrderSupport[NEG_MULTIDSTBLT_INDEX] = False;
settings->OrderSupport[NEG_MULTIPATBLT_INDEX] = False;
settings->OrderSupport[NEG_MULTISCRBLT_INDEX] = False;
settings->OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = True;
settings->OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = False;
settings->OrderSupport[NEG_LINETO_INDEX] = True;
settings->OrderSupport[NEG_POLYLINE_INDEX] = True;
settings->OrderSupport[NEG_MEMBLT_INDEX] = settings->BitmapCacheEnabled;
settings->OrderSupport[NEG_MEM3BLT_INDEX] = True;
settings->OrderSupport[NEG_MEMBLT_V2_INDEX] = settings->BitmapCacheEnabled;
settings->OrderSupport[NEG_MEM3BLT_V2_INDEX] = False;
settings->OrderSupport[NEG_SAVEBITMAP_INDEX] = False;
settings->OrderSupport[NEG_GLYPH_INDEX_INDEX] = True;
settings->OrderSupport[NEG_FAST_INDEX_INDEX] = True;
settings->OrderSupport[NEG_FAST_GLYPH_INDEX] = True;
settings->OrderSupport[NEG_POLYGON_SC_INDEX] = False;
settings->OrderSupport[NEG_POLYGON_CB_INDEX] = False;
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = False;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = False;
if (settings->RemoteFxCodec == True)
{
settings->FrameAcknowledge = False;
settings->LargePointerFlag = True;
settings->PerformanceFlags = PERF_FLAG_NONE;
rfi->rfx_context = rfx_context_new();
}
freerdp_client_load_addins(instance->context->channels, instance->settings);
freerdp_channels_pre_connect(instance->context->channels, instance);
rfi->clrconv = freerdp_clrconv_new(CLRCONV_ALPHA);
instance->context->cache = cache_new(instance->settings);
return True;
}
/*
* Initilize ald manager
* type: data type
* file: file name array
* cnt : number in file name array
* mmap: mmap file or not
*/
void ald_init(int type, char **file, int cnt, boolean mmap) {
/* check wrong type */
if (type < DRIFILETYPEMAX) {
dri[type] = dri_init(file, cnt, mmap);
if (!dri[type]->mmapped) {
cacheid = cache_new(ald_free);
}
}
}
void case_setup()
{
int ret;
g_message("--enter fun %s", __func__);
fixture.cache_ctrl = cache_new();
g_assert(fixture.cache_ctrl!=NULL);
ret = cache_init(fixture.cache_ctrl, BLOCK_SIZE, 1024, 1000, 80, 100);
g_assert(ret == 0);
}
BOOL df_pre_connect(freerdp* instance)
{
dfInfo* dfi;
BOOL bitmap_cache;
dfContext* context;
rdpSettings* settings;
dfi = (dfInfo*) malloc(sizeof(dfInfo));
ZeroMemory(dfi, sizeof(dfInfo));
context = ((dfContext*) instance->context);
context->dfi = dfi;
settings = instance->settings;
bitmap_cache = settings->BitmapCacheEnabled;
settings->OrderSupport[NEG_DSTBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_PATBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_SCRBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_OPAQUE_RECT_INDEX] = TRUE;
settings->OrderSupport[NEG_DRAWNINEGRID_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIDSTBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIPATBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTISCRBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = TRUE;
settings->OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = FALSE;
settings->OrderSupport[NEG_LINETO_INDEX] = TRUE;
settings->OrderSupport[NEG_POLYLINE_INDEX] = TRUE;
settings->OrderSupport[NEG_MEMBLT_INDEX] = bitmap_cache;
settings->OrderSupport[NEG_MEM3BLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MEMBLT_V2_INDEX] = bitmap_cache;
settings->OrderSupport[NEG_MEM3BLT_V2_INDEX] = FALSE;
settings->OrderSupport[NEG_SAVEBITMAP_INDEX] = FALSE;
settings->OrderSupport[NEG_GLYPH_INDEX_INDEX] = FALSE;
settings->OrderSupport[NEG_FAST_INDEX_INDEX] = FALSE;
settings->OrderSupport[NEG_FAST_GLYPH_INDEX] = FALSE;
settings->OrderSupport[NEG_POLYGON_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_POLYGON_CB_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;
dfi->clrconv = (CLRCONV*) malloc(sizeof(CLRCONV));
ZeroMemory(dfi->clrconv, sizeof(CLRCONV));
dfi->clrconv->alpha = 1;
dfi->clrconv->invert = 0;
dfi->clrconv->rgb555 = 0;
dfi->clrconv->palette = (rdpPalette*) malloc(sizeof(rdpPalette));
ZeroMemory(dfi->clrconv->palette, sizeof(rdpPalette));
freerdp_channels_pre_connect(instance->context->channels, instance);
instance->context->cache = cache_new(instance->settings);
return TRUE;
}
NOEXPORT int sess_new_cb(SSL *ssl, SSL_SESSION *sess) {
CLI *c;
s_log(LOG_DEBUG, "New session callback");
c=SSL_get_ex_data(ssl, index_cli);
if(c->opt->option.sessiond)
cache_new(ssl, sess);
return 1; /* leave the session in local cache for reuse */
}
BOOL gdi_init_ex(freerdp* instance, UINT32 format, UINT32 stride, BYTE* buffer,
void (*pfree)(void*))
{
UINT32 SrcFormat = gdi_get_pixel_format(instance->settings->ColorDepth);
rdpGdi* gdi = (rdpGdi*) calloc(1, sizeof(rdpGdi));
rdpContext* context = instance->context;
if (!gdi)
goto fail;
instance->context->gdi = gdi;
gdi->log = WLog_Get(TAG);
if (!gdi->log)
goto fail;
gdi->context = instance->context;
gdi->width = instance->settings->DesktopWidth;
gdi->height = instance->settings->DesktopHeight;
gdi->dstFormat = format;
/* default internal buffer format */
WLog_Print(gdi->log, WLOG_INFO, "Local framebuffer format %s",
GetColorFormatName(gdi->dstFormat));
WLog_Print(gdi->log, WLOG_INFO, "Remote framebuffer format %s",
GetColorFormatName(SrcFormat));
if (!(gdi->hdc = gdi_GetDC()))
goto fail;
gdi->hdc->format = gdi->dstFormat;
if (!gdi_init_primary(gdi, stride, gdi->dstFormat, buffer, pfree))
goto fail;
if (!(context->cache = cache_new(instance->settings)))
goto fail;
if (!freerdp_client_codecs_prepare(context->codecs, FREERDP_CODEC_ALL,
gdi->width, gdi->height))
goto fail;
gdi_register_update_callbacks(instance->update);
brush_cache_register_callbacks(instance->update);
glyph_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
palette_cache_register_callbacks(instance->update);
if (!gdi_register_graphics(instance->context->graphics))
goto fail;
return TRUE;
fail:
gdi_free(instance);
WLog_ERR(TAG, "failed to initialize gdi");
return FALSE;
}
/**
* g_mime_iconv_init:
*
* Initialize GMime's iconv cache. This *MUST* be called before any
* gmime-iconv interfaces will work correctly.
*
* Note: this function is called for you by g_mime_init().
**/
void
g_mime_iconv_init (void)
{
if (iconv_cache)
return;
g_mime_charset_map_init ();
iconv_open_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
iconv_cache = cache_new (iconv_cache_node_expire, iconv_cache_node_free,
sizeof (IconvCacheNode), ICONV_CACHE_SIZE);
}
/*
* Pre-initialize the caches.
* The caches may be initialized before or after libevent and OpenSSL.
* Returns -1 on error, 0 on success.
*/
int
cachemgr_preinit(void)
{
if (!(cachemgr_fkcrt = cache_new(cachefkcrt_init_cb)))
goto out4;
if (!(cachemgr_tgcrt = cache_new(cachetgcrt_init_cb)))
goto out3;
if (!(cachemgr_ssess = cache_new(cachessess_init_cb)))
goto out2;
if (!(cachemgr_dsess = cache_new(cachedsess_init_cb)))
goto out1;
return 0;
out1:
cache_free(cachemgr_ssess);
out2:
cache_free(cachemgr_tgcrt);
out3:
cache_free(cachemgr_fkcrt);
out4:
return -1;
}
// allocate gadget cache by copy
struct cache_t *cache_new_copy (struct cache_t *cache)
{
struct cache_t *copy, *res;
// allocate copy
copy = cache_new(cache_get_capacity(cache));
// make copy
res = cache_copy(copy, cache);
if (res == NULL)
cache_destroy(©, NULL);
return copy;
}
struct env *env_open(const char *home, uint32_t flags) {
LOG;
struct env *e;
e = xcalloc(1, sizeof(*e));
e->flags = flags;
/* tree */
e->inner_node_fanout = 16;
e->inner_default_node_size = 4 << 20; /* 4MB */
e->leaf_default_node_size = 4 << 20; /* 4MB */
e->leaf_default_basement_size = 128 << 10; /* 128KB */
/* cache */
e->cache_limits_bytes = 1024 << 20;
e->cache_high_watermark = 80; /* 80% */
e->cache_flush_period_ms = 100; /* 0.1s */
e->cache_checkpoint_period_ms = 600000; /* 60s */
/* IO */
e->use_directio = 1;
e->redo_path = "./dbbench";
e->enable_redo_log = 1;
if (!home)
home = ".";
e->dir = xcalloc(1, strlen(home) + 1);
xmemcpy(e->dir, (void*)home, strlen(home));
ness_check_dir(e->dir);
/* compress */
e->compress_method = NESS_SNAPPY_METHOD;
/* callback */
e->bt_compare_func = bt_compare_func_builtin;
/* internal */
e->cache = cache_new(e);
/* e->cache->cf_first->hdr->blocksize */
nassert(e->cache);
e->txnmgr = txnmgr_new();
nassert(e->txnmgr);
e->status = status_new();
nassert(e->status);
return e;
}
int main(int argc, char *argv[]) {
struct cache_t *cache;
cache = cache_new();
if (!cache) {
fprintf(stderr, "unable to create cache: %s\n", strerror(errno));
return 1;
}
cache_add(cache, "name", "neurodrone");
cache_add(cache, "place", "US");
cache_add(cache, "name1", "neurodrone_");
fprintf(stdout, "deleted value: %s\n", cache_remove(cache, "name"));
cache_free(cache);
return 0;
}
// Try to get the sector in cache.
// If it's in cache, get this cache, otherwise create a new cache.
struct cache_block *
cache_get(block_sector_t sector, bool dirty)
{
struct cache_block *cb = in_cache(sector);
if (cb)
{
cb->access = true;
cb->dirty |= dirty;
}
else
{
cb = cache_new();
cb->sector_no = sector;
cb->access = true;
cb->dirty = dirty;
block_read(fs_device, cb->sector_no, &cb->data);
}
//cache_read_ahead(sector); //failed to read ahead
return cb;
}
mword *_babel_root(bvm_cache *this_bvm, mword *loaded_bvm){ // _babel_root#
#ifdef BABEL_RESET_TRACE
_trace;
#endif
bvm_cache new_bvm;
bvm_cache *new_bvm_ptr = &new_bvm;
cache_new(this_bvm, new_bvm_ptr, loaded_bvm);
mword *bvm_initd = rci(cache_read_from_bvm(this_bvm, BABEL_SYM_BVM_INITD),0);
if(!rcl(bvm_initd,0)){
bvm_new(new_bvm_ptr);
lcl(bvm_initd,0) = 1;
}
else{
cache_update(new_bvm_ptr);
}
new_bvm_ptr->flags->BVM_CACHE_DIRTY = FLAG_CLR;
new_bvm_ptr->flags->BVM_CACHE_INVALID = FLAG_CLR;
babel_root_code_injection_point(new_bvm_ptr);
new_bvm_ptr->flags->BVM_CODE_LIST_EMPTY = FLAG_CLR;
interp_core(new_bvm_ptr);
this_bvm->flags->BVM_CACHE_DIRTY = FLAG_CLR;
this_bvm->flags->BVM_CACHE_INVALID = FLAG_CLR;
// XXX Enhancement: handle return-from-root
// if(new_bvm_ptr->flags->BVM_CODE_LIST_EMPTY == FLAG_SET){
// _msg("BVM_CODE_LIST_EMPTY");
// }
return nil;
}
int gdi_init(freerdp* instance, UINT32 flags, BYTE* buffer)
{
BOOL rgb555;
rdpGdi* gdi;
rdpCache* cache;
gdi = (rdpGdi*) calloc(1, sizeof(rdpGdi));
if (!gdi)
return -1;
instance->context->gdi = gdi;
gdi->context = instance->context;
cache = instance->context->cache;
gdi->codecs = instance->context->codecs;
gdi->width = instance->settings->DesktopWidth;
gdi->height = instance->settings->DesktopHeight;
gdi->srcBpp = instance->settings->ColorDepth;
gdi->primary_buffer = buffer;
/* default internal buffer format */
gdi->dstBpp = 32;
gdi->bytesPerPixel = 4;
gdi->format = PIXEL_FORMAT_XRGB32;
if (flags & CLRCONV_INVERT)
gdi->invert = TRUE;
rgb555 = (flags & CLRCONV_RGB555) ? TRUE : FALSE;
if (gdi->srcBpp > 16)
{
if (flags & CLRBUF_32BPP)
{
gdi->dstBpp = 32;
gdi->bytesPerPixel = 4;
}
else if (flags & CLRBUF_16BPP)
{
gdi->dstBpp = rgb555 ? 15 : 16;
gdi->bytesPerPixel = 2;
}
}
else
{
if (flags & CLRBUF_16BPP)
{
gdi->dstBpp = rgb555 ? 15 : 16;
gdi->bytesPerPixel = 2;
}
else if (flags & CLRBUF_32BPP)
{
gdi->dstBpp = 32;
gdi->bytesPerPixel = 4;
}
}
if (!gdi->invert)
{
if (gdi->bytesPerPixel == 4)
gdi->format = PIXEL_FORMAT_XRGB32;
else if ((gdi->bytesPerPixel == 2) && (gdi->dstBpp == 16))
gdi->format = PIXEL_FORMAT_RGB565;
else if ((gdi->bytesPerPixel == 2) && (gdi->dstBpp == 15))
gdi->format = PIXEL_FORMAT_RGB555;
}
else
{
if (gdi->bytesPerPixel == 4)
gdi->format = PIXEL_FORMAT_XBGR32;
else if ((gdi->bytesPerPixel == 2) && (gdi->dstBpp == 16))
gdi->format = PIXEL_FORMAT_BGR565;
else if ((gdi->bytesPerPixel == 2) && (gdi->dstBpp == 15))
gdi->format = PIXEL_FORMAT_BGR555;
}
gdi->hdc = gdi_GetDC();
gdi->hdc->bitsPerPixel = gdi->dstBpp;
gdi->hdc->bytesPerPixel = gdi->bytesPerPixel;
gdi->hdc->alpha = (flags & CLRCONV_ALPHA) ? TRUE : FALSE;
gdi->hdc->invert = (flags & CLRCONV_INVERT) ? TRUE : FALSE;
gdi->hdc->rgb555 = (flags & CLRCONV_RGB555) ? TRUE : FALSE;
gdi_init_primary(gdi);
gdi->tile = gdi_bitmap_new_ex(gdi, 64, 64, 32, NULL);
gdi->image = gdi_bitmap_new_ex(gdi, 64, 64, 32, NULL);
if (!cache)
{
cache = cache_new(instance->settings);
instance->context->cache = cache;
}
gdi_register_update_callbacks(instance->update);
brush_cache_register_callbacks(instance->update);
glyph_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
palette_cache_register_callbacks(instance->update);
gdi_register_graphics(instance->context->graphics);
instance->update->BitmapUpdate = gdi_bitmap_update;
return 0;
}
boolean wf_pre_connect(freerdp* instance)
{
int i1;
wfInfo* wfi;
wfContext* context;
rdpSettings* settings;
wfi = (wfInfo*) xzalloc(sizeof(wfInfo));
context = (wfContext*) instance->context;
wfi->instance = instance;
context->wfi = wfi;
settings = instance->settings;
settings->os_major_type = OSMAJORTYPE_WINDOWS;
settings->os_minor_type = OSMINORTYPE_WINDOWS_NT;
settings->order_support[NEG_DSTBLT_INDEX] = true;
settings->order_support[NEG_PATBLT_INDEX] = true;
settings->order_support[NEG_SCRBLT_INDEX] = true;
settings->order_support[NEG_OPAQUE_RECT_INDEX] = true;
settings->order_support[NEG_DRAWNINEGRID_INDEX] = false;
settings->order_support[NEG_MULTIDSTBLT_INDEX] = false;
settings->order_support[NEG_MULTIPATBLT_INDEX] = false;
settings->order_support[NEG_MULTISCRBLT_INDEX] = false;
settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = true;
settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = false;
settings->order_support[NEG_LINETO_INDEX] = true;
settings->order_support[NEG_POLYLINE_INDEX] = true;
settings->order_support[NEG_MEMBLT_INDEX] = true;
settings->order_support[NEG_MEM3BLT_INDEX] = false;
settings->order_support[NEG_SAVEBITMAP_INDEX] = false;
settings->order_support[NEG_GLYPH_INDEX_INDEX] = false;
settings->order_support[NEG_FAST_INDEX_INDEX] = false;
settings->order_support[NEG_FAST_GLYPH_INDEX] = false;
settings->order_support[NEG_POLYGON_SC_INDEX] = false;
settings->order_support[NEG_POLYGON_CB_INDEX] = false;
settings->order_support[NEG_ELLIPSE_SC_INDEX] = false;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = false;
settings->glyph_cache = false;
wfi->cursor = g_default_cursor;
wfi->fullscreen = settings->fullscreen;
wfi->fs_toggle = wfi->fullscreen;
wfi->sw_gdi = settings->sw_gdi;
wfi->clrconv = (HCLRCONV) xzalloc(sizeof(CLRCONV));
wfi->clrconv->palette = NULL;
wfi->clrconv->alpha = false;
instance->context->cache = cache_new(settings);
if (wfi->percentscreen > 0)
{
i1 = (GetSystemMetrics(SM_CXSCREEN) * wfi->percentscreen) / 100;
settings->width = i1;
i1 = (GetSystemMetrics(SM_CYSCREEN) * wfi->percentscreen) / 100;
settings->height = i1;
}
if (wfi->fs_toggle)
{
settings->width = GetSystemMetrics(SM_CXSCREEN);
settings->height = GetSystemMetrics(SM_CYSCREEN);
}
i1 = settings->width;
i1 = (i1 + 3) & (~3);
settings->width = i1;
if ((settings->width < 64) || (settings->height < 64) ||
(settings->width > 4096) || (settings->height > 4096))
{
printf("wf_pre_connect: invalid dimensions %d %d\n", settings->width, settings->height);
return 1;
}
settings->kbd_layout = (int) GetKeyboardLayout(0) & 0x0000FFFF;
freerdp_channels_pre_connect(instance->context->channels, instance);
return true;
}
struct stumpless_entry *
vstumpless_new_entry( int facility,
int severity,
const char *app_name,
const char *msgid,
const char *message,
va_list subs ) {
struct stumpless_entry *entry;
const char *effective_app_name;
size_t *app_name_length;
const char *effective_msgid;
size_t *msgid_length;
size_t *message_length;
clear_error( );
if( !entry_cache ) {
entry_cache = cache_new( sizeof( *entry ), NULL, NULL );
if( !entry_cache ) {
goto fail;
}
}
entry = cache_alloc( entry_cache );
if( !entry ) {
goto fail;
}
effective_app_name = app_name ? app_name : "-";
app_name_length = &( entry->app_name_length );
entry->app_name = cstring_to_sized_string( effective_app_name,
app_name_length );
if( !entry->app_name ) {
goto fail_app_name;
}
effective_msgid = msgid ? msgid : "-";
msgid_length = &( entry->msgid_length );
entry->msgid = cstring_to_sized_string( effective_msgid, msgid_length );
if( !entry->msgid ) {
goto fail_msgid;
}
if( !message ) {
entry->message = NULL;
entry->message_length = 0;
} else {
message_length = &( entry->message_length );
entry->message = config_format_string( message, subs, message_length );
if( !entry->message ) {
goto fail_message;
}
}
config_initialize_insertion_params( entry );
config_set_entry_wel_type( entry, severity );
entry->prival = get_prival( facility, severity );
entry->elements = NULL;
entry->element_count = 0;
return entry;
fail_message:
free_mem( entry->msgid );
fail_msgid:
free_mem( entry->app_name );
fail_app_name:
cache_free( entry_cache, entry );
fail:
return NULL;
}
void cache_recvmsg()
{
unsigned int recv_ip;
unsigned short recv_port;
unsigned char buf[1024];
struct sockaddr_in si_other;
socklen_t slen=sizeof(si_other);
uint ticks = GetTickCount();
struct cs_cachepeer_data *peer;
int received = recvfrom( cfg.cachesock, buf, sizeof(buf), 0, (struct sockaddr*)&si_other, &slen);
memcpy( &recv_ip, &si_other.sin_addr, 4);
recv_port = ntohs(si_other.sin_port);
if (received>0) {
if (flag_debugnet) {
debugf(" cache: recv data (%d) from address (%s:%d)\n", received, ip2string(recv_ip), recv_port );
debughex(buf,received);
}
// Store Data
struct cache_data req;
switch(buf[0]) {
case TYPE_REQUEST:
// Check Peer
peer = getpeerbyaddr(recv_ip,recv_port);
if (!peer) {
peer = getpeerbyip(recv_ip);
if (!peer) break;
}
peer->lastactivity = ticks;
//peer->totreq++;
// Check Multics diferent version
if ( !strcmp("MultiCS",peer->program) && (!strcmp("r63",peer->version)||!strcmp("r64",peer->version)||!strcmp("r65",peer->version)||!strcmp("r66",peer->version)||!strcmp("r67",peer->version)||!strcmp("r68",peer->version)||!strcmp("r69",peer->version)||!strcmp("r70",peer->version)||!strcmp("r71",peer->version)||!strcmp("r72",peer->version)||!strcmp("r73",peer->version)||!strcmp("r74",peer->version)||!strcmp("r75",peer->version)||!strcmp("r76",peer->version)||!strcmp("r77",peer->version)||!strcmp("r78",peer->version)||!strcmp("r79",peer->version)||!strcmp("r80",peer->version)||!strcmp("r81",peer->version)||!strcmp("r82",peer->version)||!strcmp("r83",peer->version)||!strcmp("r84",peer->version)||!strcmp("r85",peer->version)) ) break;
// Check CSP
if (received==20) { // arbiter number
strcpy(peer->program,"CSP");
break;
}
// Check Status
if (peer->disabled) break;
// Get DATA
req.tag = buf[1];
req.sid = (buf[2]<<8) | buf[3];
req.onid = (buf[4]<<8) | buf[5];
req.caid = (buf[6]<<8) | buf[7];
req.hash = (buf[8]<<24) | (buf[9]<<16) | (buf[10]<<8) |buf[11];
// Check Cache Request
if (!cache_check(&req)) break;
//
peer->reqnb++;
// ADD CACHE
struct cache_data *pcache = cache_fetch( &req );
if (pcache==NULL) {
//*debugf(" [CACHE] << Cache Request from %s %04x:%04x:%08x\n", peer->host->name, req.caid, req.sid, req.hash);
pcache = cache_new( &req );
if (cfg.cache.trackermode) {
// Send REQUEST to all Peers
struct cs_cachepeer_data *p = cfg.cachepeer;
while (p) {
if (!p->disabled)
if (p->host->ip && p->port)
if ( (p->lastactivity+75000)>ticks )
if ( !p->fblock0onid || pcache->onid )
cache_send_request(pcache,p);
p = p->next;
}
pcache->sendcache = 1;
cfg.cachereq++;
}
}
else if (!cfg.cache.trackermode) {
if ( (pcache->status==CACHE_STAT_DCW)&&(pcache->sendcache!=2) ) {
//debugf(" [CACHE] << Request Reply >> to peer %s %04x:%04x:%08x\n", peer->host->name, req.caid, req.sid, req.hash);
peer->ihitfwd++;
peer->hitfwd++;
cache_send_reply(pcache,peer);
}
}
break;
case TYPE_REPLY:
// Check Peer
peer = getpeerbyaddr(recv_ip,recv_port);
if (!peer) {
peer = getpeerbyip(recv_ip);
if (!peer) break;
}
peer->lastactivity = ticks;
//peer->totrep++;
// Check Multics diferent version
if ( !strcmp("MultiCS",peer->program) && (!strcmp("r63",peer->version)||!strcmp("r64",peer->version)||!strcmp("r65",peer->version)||!strcmp("r66",peer->version)||!strcmp("r67",peer->version)||!strcmp("r68",peer->version)||!strcmp("r69",peer->version)||!strcmp("r70",peer->version)||!strcmp("r71",peer->version)||!strcmp("r72",peer->version)||!strcmp("r73",peer->version)||!strcmp("r74",peer->version)||!strcmp("r75",peer->version)||!strcmp("r76",peer->version)||!strcmp("r77",peer->version)||!strcmp("r78",peer->version)||!strcmp("r79",peer->version)||!strcmp("r80",peer->version)||!strcmp("r81",peer->version)||!strcmp("r82",peer->version)||!strcmp("r83",peer->version)||!strcmp("r84",peer->version)||!strcmp("r85",peer->version)) ) break;
// Check Status
if (peer->disabled) break;
// 02 80 00CD 0001 0500 8D1DB359 80 // failed
// 02 80 00CD 0001 0500 8D1DB359 80 00CD 0000 0500 63339F359A663232B73158405A255DDC // OLD
// 02 80 001F 0001 0100 9A3BA1C1 80 BC02DB99DE3D526D5702D42D4C249505 0005 6361726431 // NEW
if (buf[12]!=buf[1]) {
//peer->rep_badheader++;
break;
}
req.tag = buf[1];
req.sid = (buf[2]<<8) | buf[3];
req.onid = (buf[4]<<8) | buf[5];
req.caid = (buf[6]<<8) | buf[7];
req.hash = (buf[8]<<24) | (buf[9]<<16) | (buf[10]<<8) |buf[11];
// Check Cache Request
if (!cache_check(&req)) {
//peer->rep_badfields++;
break;
}
//
if (received==13) { // FAILED
//peer->rep_failed++;
//*debugf(" [CACHE] <| Failed Cache Reply from %s (CAID:%04x SID:%04x ONID:%04x)\n", peer->host->name, req.caid, req.sid, req.onid);
// NOTHING TO DO
break;
}
else if (received>=29) {
// 02 80 001F 0001 0100 9A3BA1C1 80 BC02DB99DE3D526D5702D42D4C249505 0005 6361726431 // NEW
if ( !acceptDCW(buf+13) ) {
//peer->rep_baddcw++;
break;
}
//*debugf(" [CACHE] << Good Cache Reply from %s %04x:%04x:%08x (ONID:%04x)\n", peer->host->name, req.caid, req.sid, req.hash, req.onid);
peer->repok++; // Request+Reply
// Search for Cache data
struct cache_data *pcache = cache_fetch( &req );
if (pcache==NULL) pcache = cache_new( &req );
if (pcache->status!=CACHE_STAT_DCW) {
//*debugf(" [CACHE] Update Cache DCW %04x:%04x:%08x\n", pcache->caid, pcache->sid, pcache->hash);
pcache->peerid = peer->id;
memcpy(pcache->cw, buf+13, 16);
pcache->status = CACHE_STAT_DCW;
if (pcache->sendpipe) {
uchar buf[128]; // 32 por defecto
buf[0] = PIPE_CACHE_FIND_SUCCESS;
buf[1] = 11+2+16; // Data length
buf[2] = pcache->tag;
buf[3] = pcache->sid>>8; buf[4] = pcache->sid&0xff;
buf[5] = pcache->onid>>8; buf[6] = pcache->onid&0xff;
buf[7] = pcache->caid>>8; buf[8] = pcache->caid&0xff;
buf[9] = pcache->hash>>24; buf[10] = pcache->hash>>16; buf[11] = pcache->hash>>8; buf[12] = pcache->hash & 0xff;
buf[13] = peer->id>>8; buf[14] = peer->id&0xff;
memcpy( buf+15, pcache->cw, 16);
//*debugf(" pipe Cache->Ecm: PIPE_CACHE_FIND_SUCCESS %04x:%04x:%08x\n",pcache->caid, pcache->sid, pcache->hash); // debughex(buf, 13+16);
pipe_send( srvsocks[1], buf, 13+2+16);
//pcache->sendpipe = 0;
}
if (cfg.cache.trackermode) {
// Send REQUEST to all Peers
struct cs_cachepeer_data *p = cfg.cachepeer;
while (p) {
if (!p->disabled)
if (p->host->ip && p->port)
if ( (p->lastactivity+75000)>ticks )
if ( !p->fblock0onid || pcache->onid )
cache_send_reply(pcache,p);
p = p->next;
}
pcache->sendcache = 2;
cfg.cacherep++;
}
}
else if ( pcache->sendpipe && memcmp(pcache->cw, buf+13, 16) ) {
// resend to server
pcache->peerid = peer->id;
memcpy(pcache->cw, buf+13, 16);
pcache->status = CACHE_STAT_DCW;
uchar buf[128]; // 32 por defecto
buf[0] = PIPE_CACHE_FIND_SUCCESS;
buf[1] = 11+2+16; // Data length
buf[2] = pcache->tag;
buf[3] = pcache->sid>>8; buf[4] = pcache->sid&0xff;
buf[5] = pcache->onid>>8; buf[6] = pcache->onid&0xff;
buf[7] = pcache->caid>>8; buf[8] = pcache->caid&0xff;
buf[9] = pcache->hash>>24; buf[10] = pcache->hash>>16; buf[11] = pcache->hash>>8; buf[12] = pcache->hash & 0xff;
buf[13] = peer->id>>8; buf[14] = peer->id&0xff;
memcpy( buf+15, pcache->cw, 16);
pipe_send( srvsocks[1], buf, 13+2+16);
}
BOOL wf_pre_connect(freerdp* instance)
{
wfContext* wfc;
int desktopWidth;
int desktopHeight;
rdpContext* context;
rdpSettings* settings;
context = instance->context;
wfc = (wfContext*) instance->context;
wfc->instance = instance;
wfc->codecs = instance->context->codecs;
settings = instance->settings;
if (settings->ConnectionFile)
{
if (wfc->connectionRdpFile)
{
freerdp_client_rdp_file_free(wfc->connectionRdpFile);
}
wfc->connectionRdpFile = freerdp_client_rdp_file_new();
WLog_INFO(TAG, "Using connection file: %s", settings->ConnectionFile);
freerdp_client_parse_rdp_file(wfc->connectionRdpFile, settings->ConnectionFile);
freerdp_client_populate_settings_from_rdp_file(wfc->connectionRdpFile, settings);
}
settings->OsMajorType = OSMAJORTYPE_WINDOWS;
settings->OsMinorType = OSMINORTYPE_WINDOWS_NT;
settings->OrderSupport[NEG_DSTBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_PATBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_SCRBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_OPAQUE_RECT_INDEX] = TRUE;
settings->OrderSupport[NEG_DRAWNINEGRID_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIDSTBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIPATBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTISCRBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = TRUE;
settings->OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = FALSE;
settings->OrderSupport[NEG_LINETO_INDEX] = TRUE;
settings->OrderSupport[NEG_POLYLINE_INDEX] = TRUE;
settings->OrderSupport[NEG_MEMBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_MEM3BLT_INDEX] = FALSE;
settings->OrderSupport[NEG_SAVEBITMAP_INDEX] = FALSE;
settings->OrderSupport[NEG_GLYPH_INDEX_INDEX] = FALSE;
settings->OrderSupport[NEG_FAST_INDEX_INDEX] = FALSE;
settings->OrderSupport[NEG_FAST_GLYPH_INDEX] = FALSE;
settings->OrderSupport[NEG_POLYGON_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_POLYGON_CB_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;
settings->GlyphSupportLevel = GLYPH_SUPPORT_NONE;
wfc->fullscreen = settings->Fullscreen;
if (wfc->fullscreen)
wfc->fs_toggle = 1;
wfc->clrconv = (HCLRCONV) malloc(sizeof(CLRCONV));
ZeroMemory(wfc->clrconv, sizeof(CLRCONV));
wfc->clrconv->palette = NULL;
wfc->clrconv->alpha = FALSE;
instance->context->cache = cache_new(settings);
desktopWidth = settings->DesktopWidth;
desktopHeight = settings->DesktopHeight;
if (wfc->percentscreen > 0)
{
desktopWidth = (GetSystemMetrics(SM_CXSCREEN) * wfc->percentscreen) / 100;
settings->DesktopWidth = desktopWidth;
desktopHeight = (GetSystemMetrics(SM_CYSCREEN) * wfc->percentscreen) / 100;
settings->DesktopHeight = desktopHeight;
}
if (wfc->fullscreen)
{
if (settings->UseMultimon)
{
desktopWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
desktopHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
}
else
{
desktopWidth = GetSystemMetrics(SM_CXSCREEN);
desktopHeight = GetSystemMetrics(SM_CYSCREEN);
}
}
/* FIXME: desktopWidth has a limitation that it should be divisible by 4,
* otherwise the screen will crash when connecting to an XP desktop.*/
desktopWidth = (desktopWidth + 3) & (~3);
if (desktopWidth != settings->DesktopWidth)
{
freerdp_set_param_uint32(settings, FreeRDP_DesktopWidth, desktopWidth);
}
if (desktopHeight != settings->DesktopHeight)
{
freerdp_set_param_uint32(settings, FreeRDP_DesktopHeight, desktopHeight);
}
if ((settings->DesktopWidth < 64) || (settings->DesktopHeight < 64) ||
(settings->DesktopWidth > 4096) || (settings->DesktopHeight > 4096))
{
WLog_ERR(TAG, "invalid dimensions %d %d", settings->DesktopWidth, settings->DesktopHeight);
return 1;
}
freerdp_set_param_uint32(settings, FreeRDP_KeyboardLayout, (int) GetKeyboardLayout(0) & 0x0000FFFF);
PubSub_SubscribeChannelConnected(instance->context->pubSub,
(pChannelConnectedEventHandler) wf_OnChannelConnectedEventHandler);
PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
(pChannelDisconnectedEventHandler) wf_OnChannelDisconnectedEventHandler);
freerdp_channels_pre_connect(instance->context->channels, instance);
return TRUE;
}
void* nsca_gateway(void *u)
{
struct epoll_event ev, events[EPOLL_MAX_FD];
int n, nfds, epfd, connfd;
server_t *svr;
void *kernel;
svr = (server_t*)u;
if (!svr) {
logger(LOG_CRIT, "NSCA gateway failed: server context was NULL");
return NULL;
}
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
logger(LOG_CRIT, "NSCA gateway failed to get a socket descriptor: %s",
strerror(errno));
return NULL;
}
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(svr->config.nsca_port);
addr.sin_addr.s_addr = INADDR_ANY;
n = 1;
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) != 0) {
logger(LOG_WARNING, "NSCA gateway failed to set SO_REUSEADDR on listening socket");
return NULL;
}
if (bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) != 0) {
logger(LOG_CRIT, "NSCA gateway failed to bind socket to port %u", svr->config.nsca_port);
return NULL;
}
if (listen(sockfd, 64) != 0) {
logger(LOG_CRIT, "NSCA gateway failed to listen on port %u", svr->config.nsca_port);
return NULL;
}
if (nonblocking(sockfd) != 0) {
logger(LOG_CRIT, "NSCA gateway failed to set bound socket non-blocking (O_NONBLOCK): %s",
strerror(errno));
return NULL;
}
kernel = zmq_socket(svr->zmq, ZMQ_DEALER);
if (!kernel) {
logger(LOG_CRIT, "NSCA gateway failed to get a DEALER socket");
return NULL;
}
if (vx_vzmq_connect(kernel, KERNEL_ENDPOINT) != 0) {
logger(LOG_CRIT, "NSCA gateway failed to connect to kernel at " KERNEL_ENDPOINT);
return NULL;
}
epfd = epoll_create(256);
if (epfd < 0) {
logger(LOG_CRIT, "NSCA gateway failed to get an epoll file descriptor: %s",
strerror(errno));
return NULL;
}
memset(&ev, 0, sizeof(ev));
ev.events = EPOLLIN;
ev.data.fd = sockfd;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev) != 0) {
logger(LOG_CRIT, "Failed to add socket fd to epoll list: %s", strerror(errno));
return NULL;
}
cache_t *clients = cache_new(CLIENT_MAX, CLIENT_EXPIRE);
cache_setopt(clients, VIGOR_CACHE_DESTRUCTOR, client_free);
logger(LOG_INFO, "NSCA gateway thread starting up");
for (;;) {
nfds = epoll_wait(epfd, events, EPOLL_MAX_FD, -1);
if (nfds == -1) {
logger(LOG_CRIT, "epoll_wait encountered an error: %s", strerror(errno));
return NULL;
}
for (n = 0; n < nfds; n++) {
if (events[n].data.fd == sockfd) {
/* new inbound connection */
connfd = accept(sockfd, NULL, NULL);
if (connfd < 0) {
logger(LOG_ERR, "listener: inbound connect could not be accepted: %s",
strerror(errno));
continue;
}
if (nonblocking(connfd) != 0) {
logger(LOG_CRIT, "NSCA gateway failed to set connecion %i non-blocking (O_NONBLOCK): %s",
connfd, connfd);
close(connfd);
break;
}
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = connfd;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev) != 0) {
logger(LOG_CRIT, "NSCA gateway failed to register connection %i with epoll subsystem: %s",
connfd, strerror(errno));
return NULL;
}
/* push new client state into cache */
char *id = string("%04x", connfd);
client_t *c = client_new(connfd);
if (!cache_set(clients, id, c)) {
logger(LOG_ERR, "NSCA gateway has no more room in the connection cache, closing connection %i",
connfd);
client_free(c);
}
free(id);
} else {
char *id = string("%04x", events[n].data.fd);
client_t *c = cache_get(clients, id);
if (!c) {
logger(LOG_CRIT, "NSCA gateway received data for unknown client %s; ignoring", id);
free(id);
continue;
}
/* read what's left from the client */
ssize_t n = read(c->fd, &c->packet + c->bytes,
NSCA_PACKET_LEN - c->bytes);
if (n > 0) {
c->bytes += n;
if (c->bytes == NSCA_PACKET_LEN) {
update_kernel(kernel, c);
client_free(cache_unset(clients, id));
}
} else {
client_free(cache_unset(clients, id));
}
free(id);
}
}
}
logger(LOG_INFO, "NSCA gateway thread shutting down");
cache_free(clients);
return NULL;
}
mword *_babel(bvm_cache *this_bvm, mword *loaded_bvm, mword *arg_stack, mword *sym_table){ // _babel#
bvm_cache new_bvm;
bvm_cache *new_bvm_ptr = &new_bvm;
mword *result = nil;
cache_new(this_bvm, new_bvm_ptr, loaded_bvm);
mword *self = tptr_detag(new_bvm_ptr, tptr_detag(new_bvm_ptr, new_bvm_ptr->self)); // Could blow up due to mem_alloc()
if( !trie_exists(new_bvm_ptr, self, BABEL_SYM_BVM_INITD, nil) ){
trie_insert( new_bvm_ptr, self, BABEL_SYM_BVM_INITD, nil, _val(new_bvm_ptr,1) );
// trie_insert( new_bvm_ptr, self, BABEL_SYM_BVM_INITD, nil, _val(new_bvm_ptr,0) );
}
mword *bvm_initd = rci(cache_read_from_bvm(new_bvm_ptr, BABEL_SYM_BVM_INITD),0);
if(!rcl(bvm_initd,0)){
bvm_new(new_bvm_ptr);
lcl(bvm_initd,0) = 1;
}
else{
cache_update(new_bvm_ptr);
}
if( !trie_exists(new_bvm_ptr, self, BABEL_SYM_CODE_RESTART_POINT, nil) ){
trie_insert( new_bvm_ptr, self, BABEL_SYM_CODE_RESTART_POINT, nil, rci(new_bvm_ptr->code_ptr,0));
}
new_bvm_ptr->flags->BVM_CACHE_DIRTY = FLAG_CLR;
new_bvm_ptr->flags->BVM_CACHE_INVALID = FLAG_CLR;
cache_flush(this_bvm);
if(!is_nil(sym_table)){
trie_insert(new_bvm_ptr, tptr_detag(new_bvm_ptr, new_bvm_ptr->self), BABEL_SYM_SOFT_ROOT, nil, sym_table);
}
trie_insert(new_bvm_ptr, tptr_detag(new_bvm_ptr, new_bvm_ptr->self), BABEL_SYM_PARENT_BVM, nil, this_bvm->self);
new_bvm_ptr->flags->BVM_CODE_LIST_EMPTY = FLAG_CLR;
while(!is_nil(arg_stack)){ // give the arg-list onto the BVM's dstack
interp_push_operand(new_bvm_ptr, rci(arg_stack, 0));
arg_stack = rci(arg_stack,1);
}
interp_core(new_bvm_ptr);
cache_cp(new_bvm_ptr, this_bvm); //update flags and interp
this_bvm->self = _ith( this_bvm,
trie_lookup_hash(
new_bvm_ptr,
tptr_detag(new_bvm_ptr, new_bvm_ptr->self),
BABEL_SYM_PARENT_BVM,
nil),
2 );
cache_update(this_bvm);
this_bvm->flags->BVM_CACHE_DIRTY = FLAG_CLR;
this_bvm->flags->BVM_CACHE_INVALID = FLAG_CLR;
//copy TOS from new_bvm to this_bvm
oinfo oi;
oi.default_data = nil;
oi.required_tag = nil;
oi.mask = OI_MASK_ANY;
oi.min_size = 0;
oi.max_size = 1;
if( new_bvm_ptr->flags->BVM_RETURN_TOS_ON_EXIT == FLAG_SET
&&
(new_bvm_ptr->flags->BVM_CODE_LIST_EMPTY == FLAG_SET
||
(get_advance_type(new_bvm_ptr) == BVM_RETURN))){
get_operands(new_bvm_ptr,1,&oi);
result = oi.data;
stack_pop(new_bvm_ptr,rci(new_bvm_ptr->dstack_ptr,0));
// stack_push(this_bvm,
// rci(this_bvm->dstack_ptr,0),
// stack_new_entry(
// this_bvm,
// oi.data,
// nil));
}
// Reset all flags in case of re-entry
new_bvm_ptr->flags->BVM_RETURN_TOS_ON_EXIT = FLAG_CLR; // FIXME: This restore to previous value, not force-clear
new_bvm_ptr->flags->BVM_CODE_LIST_EMPTY = FLAG_CLR;
if(get_advance_type(new_bvm_ptr) == BVM_RETURN){
set_advance_type(new_bvm_ptr, BVM_ADVANCE);
}
this_bvm->flags->BVM_RETURN_TOS_ON_EXIT = FLAG_CLR;
this_bvm->flags->BVM_CODE_LIST_EMPTY = FLAG_CLR;
return result;
}
BOOL wf_pre_connect(freerdp* instance)
{
int i1;
wfInfo* wfi;
rdpFile* file;
wfContext* context;
rdpSettings* settings;
context = (wfContext*) instance->context;
wfi = context->wfi;
wfi->instance = instance;
settings = instance->settings;
if (settings->ConnectionFile)
{
file = freerdp_client_rdp_file_new();
fprintf(stderr, "Using connection file: %s\n", settings->ConnectionFile);
freerdp_client_parse_rdp_file(file, settings->ConnectionFile);
freerdp_client_populate_settings_from_rdp_file(file, settings);
freerdp_client_rdp_file_free(file);
}
settings->OsMajorType = OSMAJORTYPE_WINDOWS;
settings->OsMinorType = OSMINORTYPE_WINDOWS_NT;
settings->OrderSupport[NEG_DSTBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_PATBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_SCRBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_OPAQUE_RECT_INDEX] = TRUE;
settings->OrderSupport[NEG_DRAWNINEGRID_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIDSTBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIPATBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTISCRBLT_INDEX] = FALSE;
settings->OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = TRUE;
settings->OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = FALSE;
settings->OrderSupport[NEG_LINETO_INDEX] = TRUE;
settings->OrderSupport[NEG_POLYLINE_INDEX] = TRUE;
settings->OrderSupport[NEG_MEMBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_MEM3BLT_INDEX] = FALSE;
settings->OrderSupport[NEG_SAVEBITMAP_INDEX] = FALSE;
settings->OrderSupport[NEG_GLYPH_INDEX_INDEX] = FALSE;
settings->OrderSupport[NEG_FAST_INDEX_INDEX] = FALSE;
settings->OrderSupport[NEG_FAST_GLYPH_INDEX] = FALSE;
settings->OrderSupport[NEG_POLYGON_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_POLYGON_CB_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;
settings->GlyphSupportLevel = GLYPH_SUPPORT_NONE;
wfi->fullscreen = settings->Fullscreen;
wfi->fs_toggle = 1;
wfi->sw_gdi = settings->SoftwareGdi;
wfi->clrconv = (HCLRCONV) malloc(sizeof(CLRCONV));
ZeroMemory(wfi->clrconv, sizeof(CLRCONV));
wfi->clrconv->palette = NULL;
wfi->clrconv->alpha = FALSE;
instance->context->cache = cache_new(settings);
if (wfi->percentscreen > 0)
{
i1 = (GetSystemMetrics(SM_CXSCREEN) * wfi->percentscreen) / 100;
settings->DesktopWidth = i1;
i1 = (GetSystemMetrics(SM_CYSCREEN) * wfi->percentscreen) / 100;
settings->DesktopHeight = i1;
}
if (wfi->fullscreen)
{
settings->DesktopWidth = GetSystemMetrics(SM_CXSCREEN);
settings->DesktopHeight = GetSystemMetrics(SM_CYSCREEN);
}
i1 = settings->DesktopWidth;
i1 = (i1 + 3) & (~3);
settings->DesktopWidth = i1;
if ((settings->DesktopWidth < 64) || (settings->DesktopHeight < 64) ||
(settings->DesktopWidth > 4096) || (settings->DesktopHeight > 4096))
{
fprintf(stderr, "wf_pre_connect: invalid dimensions %d %d\n", settings->DesktopWidth, settings->DesktopHeight);
return 1;
}
settings->KeyboardLayout = (int) GetKeyboardLayout(0) & 0x0000FFFF;
freerdp_channels_pre_connect(instance->context->channels, instance);
return TRUE;
}
BOOL rdp_freerdp_pre_connect(freerdp* instance) {
rdpContext* context = instance->context;
rdpChannels* channels = context->channels;
guac_client* client = ((rdp_freerdp_context*) context)->client;
guac_rdp_client* rdp_client = (guac_rdp_client*) client->data;
guac_rdp_settings* settings = rdp_client->settings;
rdpBitmap* bitmap;
rdpGlyph* glyph;
rdpPointer* pointer;
rdpPrimaryUpdate* primary;
CLRCONV* clrconv;
guac_rdp_dvc_list* dvc_list = guac_rdp_dvc_list_alloc();
#ifdef HAVE_FREERDP_REGISTER_ADDIN_PROVIDER
/* Init FreeRDP add-in provider */
freerdp_register_addin_provider(freerdp_channels_load_static_addin_entry, 0);
#endif
#ifdef HAVE_FREERDP_EVENT_PUBSUB
/* Subscribe to and handle channel connected events */
PubSub_SubscribeChannelConnected(context->pubSub,
(pChannelConnectedEventHandler) guac_rdp_channel_connected);
#endif
#ifdef HAVE_FREERDP_DISPLAY_UPDATE_SUPPORT
/* Load "disp" plugin for display update */
if (settings->resize_method == GUAC_RESIZE_DISPLAY_UPDATE)
guac_rdp_disp_load_plugin(instance->context, dvc_list);
#endif
/* Load "AUDIO_INPUT" plugin for audio input*/
if (settings->enable_audio_input) {
rdp_client->audio_input = guac_rdp_audio_buffer_alloc();
guac_rdp_audio_load_plugin(instance->context, dvc_list);
}
/* Load clipboard plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"cliprdr", NULL))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load cliprdr plugin. Clipboard will not work.");
/* If RDPSND/RDPDR required, load them */
if (settings->printing_enabled
|| settings->drive_enabled
|| settings->audio_enabled) {
/* Load RDPDR plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"guacdr", client))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load guacdr plugin. Drive redirection and "
"printing will not work. Sound MAY not work.");
/* Load RDPSND plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"guacsnd", client))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load guacsnd alongside guacdr plugin. Sound "
"will not work. Drive redirection and printing MAY not "
"work.");
}
/* Load RAIL plugin if RemoteApp in use */
if (settings->remote_app != NULL) {
#ifdef LEGACY_FREERDP
RDP_PLUGIN_DATA* plugin_data = malloc(sizeof(RDP_PLUGIN_DATA) * 2);
plugin_data[0].size = sizeof(RDP_PLUGIN_DATA);
plugin_data[0].data[0] = settings->remote_app;
plugin_data[0].data[1] = settings->remote_app_dir;
plugin_data[0].data[2] = settings->remote_app_args;
plugin_data[0].data[3] = NULL;
plugin_data[1].size = 0;
/* Attempt to load rail */
if (freerdp_channels_load_plugin(channels, instance->settings,
"rail", plugin_data))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load rail plugin. RemoteApp will not work.");
#else
/* Attempt to load rail */
if (freerdp_channels_load_plugin(channels, instance->settings,
"rail", instance->settings))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load rail plugin. RemoteApp will not work.");
#endif
}
/* Load SVC plugin instances for all static channels */
if (settings->svc_names != NULL) {
char** current = settings->svc_names;
do {
guac_rdp_svc* svc = guac_rdp_alloc_svc(client, *current);
/* Attempt to load guacsvc plugin for new static channel */
if (freerdp_channels_load_plugin(channels, instance->settings,
"guacsvc", svc)) {
guac_client_log(client, GUAC_LOG_WARNING,
"Cannot create static channel \"%s\": failed to load guacsvc plugin.",
svc->name);
guac_rdp_free_svc(svc);
}
/* Store and log on success */
else {
guac_rdp_add_svc(client, svc);
guac_client_log(client, GUAC_LOG_INFO, "Created static channel \"%s\"...",
svc->name);
}
} while (*(++current) != NULL);
}
/* Load DRDYNVC plugin if required */
if (guac_rdp_load_drdynvc(instance->context, dvc_list))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load drdynvc plugin. Display update and audio "
"input support will be disabled.");
/* Dynamic virtual channel list is no longer needed */
guac_rdp_dvc_list_free(dvc_list);
/* Init color conversion structure */
clrconv = calloc(1, sizeof(CLRCONV));
clrconv->alpha = 1;
clrconv->invert = 0;
clrconv->rgb555 = 0;
clrconv->palette = calloc(1, sizeof(rdpPalette));
((rdp_freerdp_context*) context)->clrconv = clrconv;
/* Init FreeRDP cache */
instance->context->cache = cache_new(instance->settings);
/* Set up bitmap handling */
bitmap = calloc(1, sizeof(rdpBitmap));
bitmap->size = sizeof(guac_rdp_bitmap);
bitmap->New = guac_rdp_bitmap_new;
bitmap->Free = guac_rdp_bitmap_free;
bitmap->Paint = guac_rdp_bitmap_paint;
bitmap->Decompress = guac_rdp_bitmap_decompress;
bitmap->SetSurface = guac_rdp_bitmap_setsurface;
graphics_register_bitmap(context->graphics, bitmap);
free(bitmap);
/* Set up glyph handling */
glyph = calloc(1, sizeof(rdpGlyph));
glyph->size = sizeof(guac_rdp_glyph);
glyph->New = guac_rdp_glyph_new;
glyph->Free = guac_rdp_glyph_free;
glyph->Draw = guac_rdp_glyph_draw;
glyph->BeginDraw = guac_rdp_glyph_begindraw;
glyph->EndDraw = guac_rdp_glyph_enddraw;
graphics_register_glyph(context->graphics, glyph);
free(glyph);
/* Set up pointer handling */
pointer = calloc(1, sizeof(rdpPointer));
pointer->size = sizeof(guac_rdp_pointer);
pointer->New = guac_rdp_pointer_new;
pointer->Free = guac_rdp_pointer_free;
pointer->Set = guac_rdp_pointer_set;
#ifdef HAVE_RDPPOINTER_SETNULL
pointer->SetNull = guac_rdp_pointer_set_null;
#endif
#ifdef HAVE_RDPPOINTER_SETDEFAULT
pointer->SetDefault = guac_rdp_pointer_set_default;
#endif
graphics_register_pointer(context->graphics, pointer);
free(pointer);
/* Set up GDI */
instance->update->DesktopResize = guac_rdp_gdi_desktop_resize;
instance->update->EndPaint = guac_rdp_gdi_end_paint;
instance->update->Palette = guac_rdp_gdi_palette_update;
instance->update->SetBounds = guac_rdp_gdi_set_bounds;
primary = instance->update->primary;
primary->DstBlt = guac_rdp_gdi_dstblt;
primary->PatBlt = guac_rdp_gdi_patblt;
primary->ScrBlt = guac_rdp_gdi_scrblt;
primary->MemBlt = guac_rdp_gdi_memblt;
primary->OpaqueRect = guac_rdp_gdi_opaquerect;
pointer_cache_register_callbacks(instance->update);
glyph_cache_register_callbacks(instance->update);
brush_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
palette_cache_register_callbacks(instance->update);
/* Init channels (pre-connect) */
if (freerdp_channels_pre_connect(channels, instance)) {
guac_client_abort(client, GUAC_PROTOCOL_STATUS_SERVER_ERROR, "Error initializing RDP client channel manager");
return FALSE;
}
return TRUE;
}
int __guac_receive_channel_data(freerdp* rdp_inst, UINT16 channelId, BYTE* data, int size, int flags, int total_size) {
#else
int __guac_receive_channel_data(freerdp* rdp_inst, int channelId, UINT8* data, int size, int flags, int total_size) {
#endif
return freerdp_channels_data(rdp_inst, channelId, data, size, flags, total_size);
}
#ifdef HAVE_FREERDP_EVENT_PUBSUB
/**
* Called whenever a channel connects via the PubSub event system within
* FreeRDP.
*
* @param context The rdpContext associated with the active RDP session.
* @param e Event-specific arguments, mainly the name of the channel, and a
* reference to the associated plugin loaded for that channel by
* FreeRDP.
*/
static void guac_rdp_channel_connected(rdpContext* context,
ChannelConnectedEventArgs* e) {
#ifdef HAVE_RDPSETTINGS_SUPPORTDISPLAYCONTROL
/* Store reference to the display update plugin once it's connected */
if (strcmp(e->name, DISP_DVC_CHANNEL_NAME) == 0) {
DispClientContext* disp = (DispClientContext*) e->pInterface;
guac_client* client = ((rdp_freerdp_context*) context)->client;
rdp_guac_client_data* guac_client_data =
(rdp_guac_client_data*) client->data;
/* Init module with current display size */
guac_rdp_disp_set_size(guac_client_data->disp, context,
guac_rdp_get_width(context->instance),
guac_rdp_get_height(context->instance));
/* Store connected channel */
guac_rdp_disp_connect(guac_client_data->disp, disp);
guac_client_log(client, GUAC_LOG_DEBUG,
"Display update channel connected.");
}
#endif
}
#endif
BOOL rdp_freerdp_pre_connect(freerdp* instance) {
rdpContext* context = instance->context;
guac_client* client = ((rdp_freerdp_context*) context)->client;
rdpChannels* channels = context->channels;
rdpBitmap* bitmap;
rdpGlyph* glyph;
rdpPointer* pointer;
rdpPrimaryUpdate* primary;
CLRCONV* clrconv;
rdp_guac_client_data* guac_client_data =
(rdp_guac_client_data*) client->data;
#ifdef HAVE_FREERDP_REGISTER_ADDIN_PROVIDER
/* Init FreeRDP add-in provider */
freerdp_register_addin_provider(freerdp_channels_load_static_addin_entry, 0);
#endif
#ifdef HAVE_FREERDP_EVENT_PUBSUB
/* Subscribe to and handle channel connected events */
PubSub_SubscribeChannelConnected(context->pubSub,
(pChannelConnectedEventHandler) guac_rdp_channel_connected);
#endif
#ifdef HAVE_FREERDP_DISPLAY_UPDATE_SUPPORT
/* Load virtual channel management plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"drdynvc", instance->settings))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load drdynvc plugin.");
/* Init display update plugin */
guac_client_data->disp = guac_rdp_disp_alloc();
guac_rdp_disp_load_plugin(instance->context);
#endif
/* Load clipboard plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"cliprdr", NULL))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load cliprdr plugin. Clipboard will not work.");
/* If audio enabled, choose an encoder */
if (guac_client_data->settings.audio_enabled) {
guac_client_data->audio = guac_audio_stream_alloc(client, NULL);
/* If an encoding is available, load the sound plugin */
if (guac_client_data->audio != NULL) {
/* Load sound plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"guacsnd", guac_client_data->audio))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load guacsnd plugin. Audio will not work.");
}
else
guac_client_log(client, GUAC_LOG_INFO,
"No available audio encoding. Sound disabled.");
} /* end if audio enabled */
/* Load filesystem if drive enabled */
if (guac_client_data->settings.drive_enabled) {
/* Allocate filesystem */
guac_client_data->filesystem =
guac_rdp_fs_alloc(client, guac_client_data->settings.drive_path,
guac_client_data->settings.create_drive_path);
/* Use for basic uploads if no other handler set */
if (client->file_handler == NULL)
client->file_handler = guac_rdp_upload_file_handler;
}
/* If RDPDR required, load it */
if (guac_client_data->settings.printing_enabled
|| guac_client_data->settings.drive_enabled
|| guac_client_data->settings.audio_enabled) {
/* Load RDPDR plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"guacdr", client))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load guacdr plugin. Drive redirection and printing will not work.");
}
/* Load RAIL plugin if RemoteApp in use */
if (guac_client_data->settings.remote_app != NULL) {
#ifdef LEGACY_FREERDP
RDP_PLUGIN_DATA* plugin_data = malloc(sizeof(RDP_PLUGIN_DATA) * 2);
plugin_data[0].size = sizeof(RDP_PLUGIN_DATA);
plugin_data[0].data[0] = guac_client_data->settings.remote_app;
plugin_data[0].data[1] = guac_client_data->settings.remote_app_dir;
plugin_data[0].data[2] = guac_client_data->settings.remote_app_args;
plugin_data[0].data[3] = NULL;
plugin_data[1].size = 0;
/* Attempt to load rail */
if (freerdp_channels_load_plugin(channels, instance->settings,
"rail", plugin_data))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load rail plugin. RemoteApp will not work.");
#else
/* Attempt to load rail */
if (freerdp_channels_load_plugin(channels, instance->settings,
"rail", instance->settings))
guac_client_log(client, GUAC_LOG_WARNING,
"Failed to load rail plugin. RemoteApp will not work.");
#endif
}
/* Load SVC plugin instances for all static channels */
if (guac_client_data->settings.svc_names != NULL) {
char** current = guac_client_data->settings.svc_names;
do {
guac_rdp_svc* svc = guac_rdp_alloc_svc(client, *current);
/* Attempt to load guacsvc plugin for new static channel */
if (freerdp_channels_load_plugin(channels, instance->settings,
"guacsvc", svc)) {
guac_client_log(client, GUAC_LOG_WARNING,
"Cannot create static channel \"%s\": failed to load guacsvc plugin.",
svc->name);
guac_rdp_free_svc(svc);
}
/* Store and log on success */
else {
guac_rdp_add_svc(client, svc);
guac_client_log(client, GUAC_LOG_INFO, "Created static channel \"%s\"...",
svc->name);
}
} while (*(++current) != NULL);
}
/* Init color conversion structure */
clrconv = calloc(1, sizeof(CLRCONV));
clrconv->alpha = 1;
clrconv->invert = 0;
clrconv->rgb555 = 0;
clrconv->palette = calloc(1, sizeof(rdpPalette));
((rdp_freerdp_context*) context)->clrconv = clrconv;
/* Init FreeRDP cache */
instance->context->cache = cache_new(instance->settings);
/* Set up bitmap handling */
bitmap = calloc(1, sizeof(rdpBitmap));
bitmap->size = sizeof(guac_rdp_bitmap);
bitmap->New = guac_rdp_bitmap_new;
bitmap->Free = guac_rdp_bitmap_free;
bitmap->Paint = guac_rdp_bitmap_paint;
bitmap->Decompress = guac_rdp_bitmap_decompress;
bitmap->SetSurface = guac_rdp_bitmap_setsurface;
graphics_register_bitmap(context->graphics, bitmap);
free(bitmap);
/* Set up glyph handling */
glyph = calloc(1, sizeof(rdpGlyph));
glyph->size = sizeof(guac_rdp_glyph);
glyph->New = guac_rdp_glyph_new;
glyph->Free = guac_rdp_glyph_free;
glyph->Draw = guac_rdp_glyph_draw;
glyph->BeginDraw = guac_rdp_glyph_begindraw;
glyph->EndDraw = guac_rdp_glyph_enddraw;
graphics_register_glyph(context->graphics, glyph);
free(glyph);
/* Set up pointer handling */
pointer = calloc(1, sizeof(rdpPointer));
pointer->size = sizeof(guac_rdp_pointer);
pointer->New = guac_rdp_pointer_new;
pointer->Free = guac_rdp_pointer_free;
pointer->Set = guac_rdp_pointer_set;
#ifdef HAVE_RDPPOINTER_SETNULL
pointer->SetNull = guac_rdp_pointer_set_null;
#endif
#ifdef HAVE_RDPPOINTER_SETDEFAULT
pointer->SetDefault = guac_rdp_pointer_set_default;
#endif
graphics_register_pointer(context->graphics, pointer);
free(pointer);
/* Set up GDI */
instance->update->DesktopResize = guac_rdp_gdi_desktop_resize;
instance->update->EndPaint = guac_rdp_gdi_end_paint;
instance->update->Palette = guac_rdp_gdi_palette_update;
instance->update->SetBounds = guac_rdp_gdi_set_bounds;
primary = instance->update->primary;
primary->DstBlt = guac_rdp_gdi_dstblt;
primary->PatBlt = guac_rdp_gdi_patblt;
primary->ScrBlt = guac_rdp_gdi_scrblt;
primary->MemBlt = guac_rdp_gdi_memblt;
primary->OpaqueRect = guac_rdp_gdi_opaquerect;
pointer_cache_register_callbacks(instance->update);
glyph_cache_register_callbacks(instance->update);
brush_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
palette_cache_register_callbacks(instance->update);
/* Init channels (pre-connect) */
if (freerdp_channels_pre_connect(channels, instance)) {
guac_client_abort(client, GUAC_PROTOCOL_STATUS_SERVER_ERROR, "Error initializing RDP client channel manager");
return FALSE;
}
return TRUE;
}
PathResolver *self = g_new0(PathResolver, 1);
self->super.resolve_elem = path_resolver_resolve;
self->super.free_elem = g_free;
self->super.free_fn = path_resolver_free;
self->configure_variables = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
path_resolver_populate_configure_variables(self, sysprefix);
return &self->super;
}
static gchar *
lookup_sysprefix(void)
{
gchar *v;
v = getenv("SYSLOGNG_PREFIX");
if (v)
return v;
return SYSLOG_NG_PATH_PREFIX;
}
const gchar *
get_installation_path_for(const gchar *template)
{
if (!path_cache)
path_cache = cache_new(path_resolver_new(lookup_sysprefix()));
return cache_lookup(path_cache, template);
}
boolean rdp_freerdp_pre_connect(freerdp* instance) {
rdpContext* context = instance->context;
guac_client* client = ((rdp_freerdp_context*) context)->client;
rdpChannels* channels = context->channels;
rdpBitmap* bitmap;
rdpGlyph* glyph;
rdpPointer* pointer;
rdpPrimaryUpdate* primary;
CLRCONV* clrconv;
int i;
rdp_guac_client_data* guac_client_data =
(rdp_guac_client_data*) client->data;
/* Load clipboard plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"cliprdr", NULL))
guac_client_log_error(client, "Failed to load cliprdr plugin.");
/* If audio enabled, choose an encoder */
if (guac_client_data->audio_enabled) {
/* Choose an encoding */
for (i=0; client->info.audio_mimetypes[i] != NULL; i++) {
const char* mimetype = client->info.audio_mimetypes[i];
#ifdef ENABLE_OGG
/* If Ogg is supported, done. */
if (strcmp(mimetype, ogg_encoder->mimetype) == 0) {
guac_client_log_info(client, "Loading Ogg Vorbis encoder.");
guac_client_data->audio = audio_stream_alloc(client,
ogg_encoder);
break;
}
#endif
/* If wav is supported, done. */
if (strcmp(mimetype, wav_encoder->mimetype) == 0) {
guac_client_log_info(client, "Loading wav encoder.");
guac_client_data->audio = audio_stream_alloc(client,
wav_encoder);
break;
}
}
/* If an encoding is available, load the sound plugin */
if (guac_client_data->audio != NULL) {
/* Load sound plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"guac_rdpsnd", guac_client_data->audio))
guac_client_log_error(client,
"Failed to load guac_rdpsnd plugin.");
}
else
guac_client_log_info(client,
"No available audio encoding. Sound disabled.");
} /* end if audio enabled */
/* If printing enabled, load rdpdr */
if (guac_client_data->printing_enabled) {
/* Load RDPDR plugin */
if (freerdp_channels_load_plugin(channels, instance->settings,
"guac_rdpdr", client))
guac_client_log_error(client,
"Failed to load guac_rdpdr plugin.");
} /* end if printing enabled */
/* Init color conversion structure */
clrconv = xnew(CLRCONV);
clrconv->alpha = 1;
clrconv->invert = 0;
clrconv->rgb555 = 0;
clrconv->palette = xnew(rdpPalette);
((rdp_freerdp_context*) context)->clrconv = clrconv;
/* Init FreeRDP cache */
instance->context->cache = cache_new(instance->settings);
/* Set up bitmap handling */
bitmap = xnew(rdpBitmap);
bitmap->size = sizeof(guac_rdp_bitmap);
bitmap->New = guac_rdp_bitmap_new;
bitmap->Free = guac_rdp_bitmap_free;
bitmap->Paint = guac_rdp_bitmap_paint;
bitmap->Decompress = guac_rdp_bitmap_decompress;
bitmap->SetSurface = guac_rdp_bitmap_setsurface;
graphics_register_bitmap(context->graphics, bitmap);
xfree(bitmap);
/* Set up glyph handling */
glyph = xnew(rdpGlyph);
glyph->size = sizeof(guac_rdp_glyph);
glyph->New = guac_rdp_glyph_new;
glyph->Free = guac_rdp_glyph_free;
glyph->Draw = guac_rdp_glyph_draw;
glyph->BeginDraw = guac_rdp_glyph_begindraw;
glyph->EndDraw = guac_rdp_glyph_enddraw;
graphics_register_glyph(context->graphics, glyph);
xfree(glyph);
/* Set up pointer handling */
pointer = xnew(rdpPointer);
pointer->size = sizeof(guac_rdp_pointer);
pointer->New = guac_rdp_pointer_new;
pointer->Free = guac_rdp_pointer_free;
pointer->Set = guac_rdp_pointer_set;
#ifdef HAVE_RDPPOINTER_SETNULL
pointer->SetNull = guac_rdp_pointer_set_null;
#endif
#ifdef HAVE_RDPPOINTER_SETDEFAULT
pointer->SetDefault = guac_rdp_pointer_set_default;
#endif
graphics_register_pointer(context->graphics, pointer);
xfree(pointer);
/* Set up GDI */
instance->update->EndPaint = guac_rdp_gdi_end_paint;
instance->update->Palette = guac_rdp_gdi_palette_update;
instance->update->SetBounds = guac_rdp_gdi_set_bounds;
primary = instance->update->primary;
primary->DstBlt = guac_rdp_gdi_dstblt;
primary->PatBlt = guac_rdp_gdi_patblt;
primary->ScrBlt = guac_rdp_gdi_scrblt;
primary->MemBlt = guac_rdp_gdi_memblt;
primary->OpaqueRect = guac_rdp_gdi_opaquerect;
pointer_cache_register_callbacks(instance->update);
glyph_cache_register_callbacks(instance->update);
brush_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
palette_cache_register_callbacks(instance->update);
/* Init channels (pre-connect) */
if (freerdp_channels_pre_connect(channels, instance)) {
guac_protocol_send_error(client->socket, "Error initializing RDP client channel manager");
guac_socket_flush(client->socket);
return false;
}
return true;
}
