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; }