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

[server] make settings opaque

This commit is contained in:
akallabeth 2023-10-13 12:04:24 +02:00 committed by akallabeth
parent eb445f7c43
commit 1f236ade7a
15 changed files with 466 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
server/Mac/mf_peer.c
View File

@ -180,10 +180,13 @@ static BOOL mf_peer_context_new(freerdp_peer* client, rdpContext* context)
if (!(peer->info = mf_info_get_instance())) if (!(peer->info = mf_info_get_instance()))
return FALSE; return FALSE;
if (!(peer->rfx_context = rfx_context_new_ex(TRUE, settings->ThreadingFlags))) if (!(peer->rfx_context = rfx_context_new_ex(
TRUE, freerdp_settings_get_uint32(settings, FreeRDP_ThreadingFlags))))
goto fail; goto fail;
rfx_context_reset(peer->rfx_context, settings->DesktopWidth, settings->DesktopHeight); rfx_context_reset(peer->rfx_context,
freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
rfx_context_set_mode(peer->rfx_context, RLGR3); rfx_context_set_mode(peer->rfx_context, RLGR3);
rfx_context_set_pixel_format(peer->rfx_context, PIXEL_FORMAT_BGRA32); rfx_context_set_pixel_format(peer->rfx_context, PIXEL_FORMAT_BGRA32);
@ -276,13 +279,15 @@ static BOOL mf_peer_post_connect(freerdp_peer* client)
// mfi->servscreen_height = 1800 / mfi->scale; // mfi->servscreen_height = 1800 / mfi->scale;
UINT32 bitsPerPixel = 32; UINT32 bitsPerPixel = 32;
if ((settings->DesktopWidth != mfi->servscreen_width) || if ((freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) != mfi->servscreen_width) ||
(settings->DesktopHeight != mfi->servscreen_height)) (freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) != mfi->servscreen_height))
{ {
} }
settings->DesktopWidth = mfi->servscreen_width; if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, mfi->servscreen_width))
settings->DesktopHeight = mfi->servscreen_height; return FALSE;
if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, mfi->servscreen_height))
return FALSE;
if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, bitsPerPixel)) if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, bitsPerPixel))
return FALSE; return FALSE;
@ -318,7 +323,9 @@ static BOOL mf_peer_activate(freerdp_peer* client)
rdpSettings* settings = client->context->settings; rdpSettings* settings = client->context->settings;
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
rfx_context_reset(context->rfx_context, settings->DesktopWidth, settings->DesktopHeight); rfx_context_reset(context->rfx_context,
freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
context->activated = TRUE; context->activated = TRUE;
return TRUE; return TRUE;
} }
@ -380,13 +387,17 @@ static void* mf_peer_main_loop(void* arg)
if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, cert, 1)) if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, cert, 1))
goto fail; goto fail;
settings->NlaSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
settings->RemoteFxCodec = TRUE; goto fail;
if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec, TRUE))
goto fail;
if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32)) if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
goto fail; goto fail;
settings->SuppressOutput = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE))
settings->RefreshRect = FALSE; goto fail;
if (!freerdp_settings_set_bool(settings, FreeRDP_RefreshRect, FALSE))
goto fail;
client->PostConnect = mf_peer_post_connect; client->PostConnect = mf_peer_post_connect;
client->Activate = mf_peer_activate; client->Activate = mf_peer_activate;

144
server/Sample/sfreerdp.c
View File

@ -115,7 +115,8 @@ static BOOL test_peer_context_new(freerdp_peer* client, rdpContext* ctx)
WINPR_ASSERT(context); WINPR_ASSERT(context);
WINPR_ASSERT(ctx->settings); WINPR_ASSERT(ctx->settings);
if (!(context->rfx_context = rfx_context_new_ex(TRUE, ctx->settings->ThreadingFlags))) if (!(context->rfx_context = rfx_context_new_ex(
TRUE, freerdp_settings_get_uint32(ctx->settings, FreeRDP_ThreadingFlags))))
goto fail; goto fail;
if (!rfx_context_reset(context->rfx_context, SAMPLE_SERVER_DEFAULT_WIDTH, if (!rfx_context_reset(context->rfx_context, SAMPLE_SERVER_DEFAULT_WIDTH,
@ -231,17 +232,18 @@ static BOOL test_peer_draw_background(freerdp_peer* client)
update = client->context->update; update = client->context->update;
WINPR_ASSERT(update); WINPR_ASSERT(update);
if (!settings->RemoteFxCodec && !freerdp_settings_get_bool(settings, FreeRDP_NSCodec)) const BOOL RemoteFxCodec = freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec);
if (!RemoteFxCodec && !freerdp_settings_get_bool(settings, FreeRDP_NSCodec))
return FALSE; return FALSE;
WINPR_ASSERT(settings->DesktopWidth <= UINT16_MAX); WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) <= UINT16_MAX);
WINPR_ASSERT(settings->DesktopHeight <= UINT16_MAX); WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) <= UINT16_MAX);
s = test_peer_stream_init(context); s = test_peer_stream_init(context);
rect.x = 0; rect.x = 0;
rect.y = 0; rect.y = 0;
rect.width = (UINT16)settings->DesktopWidth; rect.width = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
rect.height = (UINT16)settings->DesktopHeight; rect.height = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
size = rect.width * rect.height * 3ULL; size = rect.width * rect.height * 3ULL;
if (!(rgb_data = malloc(size))) if (!(rgb_data = malloc(size)))
@ -252,7 +254,7 @@ static BOOL test_peer_draw_background(freerdp_peer* client)
memset(rgb_data, 0xA0, size); memset(rgb_data, 0xA0, size);
if (settings->RemoteFxCodec) if (RemoteFxCodec)
{ {
WLog_DBG(TAG, "Using RemoteFX codec"); WLog_DBG(TAG, "Using RemoteFX codec");
if (!rfx_compose_message(context->rfx_context, s, &rect, 1, rgb_data, rect.width, if (!rfx_compose_message(context->rfx_context, s, &rect, 1, rgb_data, rect.width,
@ -261,8 +263,10 @@ static BOOL test_peer_draw_background(freerdp_peer* client)
goto out; goto out;
} }
WINPR_ASSERT(settings->RemoteFxCodecId <= UINT16_MAX); const UINT32 RemoteFxCodecId =
cmd.bmp.codecID = (UINT16)settings->RemoteFxCodecId; freerdp_settings_get_uint32(settings, FreeRDP_RemoteFxCodecId);
WINPR_ASSERT(RemoteFxCodecId <= UINT16_MAX);
cmd.bmp.codecID = (UINT16)RemoteFxCodecId;
cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS; cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS;
} }
else else
@ -270,8 +274,9 @@ static BOOL test_peer_draw_background(freerdp_peer* client)
WLog_DBG(TAG, "Using NSCodec"); WLog_DBG(TAG, "Using NSCodec");
nsc_compose_message(context->nsc_context, s, rgb_data, rect.width, rect.height, nsc_compose_message(context->nsc_context, s, rgb_data, rect.width, rect.height,
rect.width * 3ULL); rect.width * 3ULL);
WINPR_ASSERT(settings->NSCodecId <= UINT16_MAX); const UINT32 NSCodecId = freerdp_settings_get_uint32(settings, FreeRDP_NSCodecId);
cmd.bmp.codecID = (UINT16)settings->NSCodecId; WINPR_ASSERT(NSCodecId <= UINT16_MAX);
cmd.bmp.codecID = (UINT16)NSCodecId;
cmd.cmdType = CMDTYPE_SET_SURFACE_BITS; cmd.cmdType = CMDTYPE_SET_SURFACE_BITS;
} }
@ -313,7 +318,8 @@ static BOOL test_peer_load_icon(freerdp_peer* client)
settings = client->context->settings; settings = client->context->settings;
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
if (!settings->RemoteFxCodec && !freerdp_settings_get_bool(settings, FreeRDP_NSCodec)) if (!freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec) &&
!freerdp_settings_get_bool(settings, FreeRDP_NSCodec))
{ {
WLog_ERR(TAG, "Client doesn't support RemoteFX or NSCodec"); WLog_ERR(TAG, "Client doesn't support RemoteFX or NSCodec");
return FALSE; return FALSE;
@ -410,16 +416,20 @@ static void test_peer_draw_icon(freerdp_peer* client, UINT32 x, UINT32 y)
rect.width = context->icon_width; rect.width = context->icon_width;
rect.height = context->icon_height; rect.height = context->icon_height;
if (settings->RemoteFxCodec) const BOOL RemoteFxCodec = freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec);
if (RemoteFxCodec)
{ {
WINPR_ASSERT(settings->RemoteFxCodecId <= UINT16_MAX); const UINT32 RemoteFxCodecId =
cmd.bmp.codecID = (UINT16)settings->RemoteFxCodecId; freerdp_settings_get_uint32(settings, FreeRDP_RemoteFxCodecId);
WINPR_ASSERT(RemoteFxCodecId <= UINT16_MAX);
cmd.bmp.codecID = (UINT16)RemoteFxCodecId;
cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS; cmd.cmdType = CMDTYPE_STREAM_SURFACE_BITS;
} }
else else
{ {
WINPR_ASSERT(settings->NSCodecId <= UINT16_MAX); const UINT32 NSCodecId = freerdp_settings_get_uint32(settings, FreeRDP_NSCodecId);
cmd.bmp.codecID = (UINT16)settings->NSCodecId; WINPR_ASSERT(NSCodecId <= UINT16_MAX);
cmd.bmp.codecID = (UINT16)NSCodecId;
cmd.cmdType = CMDTYPE_SET_SURFACE_BITS; cmd.cmdType = CMDTYPE_SET_SURFACE_BITS;
} }
@ -427,7 +437,7 @@ static void test_peer_draw_icon(freerdp_peer* client, UINT32 x, UINT32 y)
{ {
s = test_peer_stream_init(context); s = test_peer_stream_init(context);
if (settings->RemoteFxCodec) if (RemoteFxCodec)
rfx_compose_message(context->rfx_context, s, &rect, 1, context->bg_data, rect.width, rfx_compose_message(context->rfx_context, s, &rect, 1, context->bg_data, rect.width,
rect.height, rect.width * 3); rect.height, rect.width * 3);
else else
@ -450,7 +460,7 @@ static void test_peer_draw_icon(freerdp_peer* client, UINT32 x, UINT32 y)
s = test_peer_stream_init(context); s = test_peer_stream_init(context);
if (settings->RemoteFxCodec) if (RemoteFxCodec)
rfx_compose_message(context->rfx_context, s, &rect, 1, context->icon_data, rect.width, rfx_compose_message(context->rfx_context, s, &rect, 1, context->icon_data, rect.width,
rect.height, rect.width * 3); rect.height, rect.width * 3);
else else
@ -660,31 +670,40 @@ static BOOL tf_peer_post_connect(freerdp_peer* client)
* callback returns. * callback returns.
*/ */
WLog_DBG(TAG, "Client %s is activated (osMajorType %" PRIu32 " osMinorType %" PRIu32 ")", WLog_DBG(TAG, "Client %s is activated (osMajorType %" PRIu32 " osMinorType %" PRIu32 ")",
client->local ? "(local)" : client->hostname, settings->OsMajorType, client->local ? "(local)" : client->hostname,
settings->OsMinorType); freerdp_settings_get_uint32(settings, FreeRDP_OsMajorType),
freerdp_settings_get_uint32(settings, FreeRDP_OsMinorType));
if (settings->AutoLogonEnabled) if (freerdp_settings_get_bool(settings, FreeRDP_AutoLogonEnabled))
{ {
WLog_DBG(TAG, " and wants to login automatically as %s\\%s", const char* Username = freerdp_settings_get_string(settings, FreeRDP_Username);
settings->Domain ? settings->Domain : "", settings->Username); const char* Domain = freerdp_settings_get_string(settings, FreeRDP_Domain);
WLog_DBG(TAG, " and wants to login automatically as %s\\%s", Domain ? Domain : "",
Username);
/* A real server may perform OS login here if NLA is not executed previously. */ /* A real server may perform OS login here if NLA is not executed previously. */
} }
WLog_DBG(TAG, ""); WLog_DBG(TAG, "");
WLog_DBG(TAG, "Client requested desktop: %" PRIu32 "x%" PRIu32 "x%" PRIu32 "", WLog_DBG(TAG, "Client requested desktop: %" PRIu32 "x%" PRIu32 "x%" PRIu32 "",
settings->DesktopWidth, settings->DesktopHeight, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight),
freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth)); freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
#if (SAMPLE_SERVER_USE_CLIENT_RESOLUTION == 1) #if (SAMPLE_SERVER_USE_CLIENT_RESOLUTION == 1)
if (!rfx_context_reset(context->rfx_context, settings->DesktopWidth, settings->DesktopHeight)) if (!rfx_context_reset(context->rfx_context,
freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
return FALSE; return FALSE;
WLog_DBG(TAG, "Using resolution requested by client."); WLog_DBG(TAG, "Using resolution requested by client.");
#else #else
client->settings->DesktopWidth = context->rfx_context->width; client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) =
client->settings->DesktopHeight = context->rfx_context->height; context->rfx_context->width;
WLog_DBG(TAG, "Resizing client to %" PRIu32 "x%" PRIu32 "", client->settings->DesktopWidth, client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) =
client->settings->DesktopHeight); context->rfx_context->height;
WLog_DBG(TAG, "Resizing client to %" PRIu32 "x%" PRIu32 "",
client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
client->freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight));
client->update->DesktopResize(client->update->context); client->update->DesktopResize(client->update->context);
#endif #endif
@ -760,14 +779,16 @@ static BOOL tf_peer_activate(freerdp_peer* client)
WINPR_ASSERT(info); WINPR_ASSERT(info);
context->activated = TRUE; context->activated = TRUE;
// client->settings->CompressionLevel = PACKET_COMPR_TYPE_8K; // PACKET_COMPR_TYPE_8K;
// client->settings->CompressionLevel = PACKET_COMPR_TYPE_64K; // PACKET_COMPR_TYPE_64K;
// client->settings->CompressionLevel = PACKET_COMPR_TYPE_RDP6; // PACKET_COMPR_TYPE_RDP6;
settings->CompressionLevel = PACKET_COMPR_TYPE_RDP8; if (!freerdp_settings_set_uint32(settings, FreeRDP_CompressionLevel, PACKET_COMPR_TYPE_RDP8))
return FALSE;
if (info->test_pcap_file != NULL) if (info->test_pcap_file != NULL)
{ {
freerdp_settings_set_bool(settings, FreeRDP_DumpRemoteFx, TRUE); if (!freerdp_settings_set_bool(settings, FreeRDP_DumpRemoteFx, TRUE))
return FALSE;
if (!tf_peer_dump_rfx(client)) if (!tf_peer_dump_rfx(client))
return FALSE; return FALSE;
@ -816,19 +837,26 @@ static BOOL tf_peer_keyboard_event(rdpInput* input, UINT16 flags, UINT8 code)
if (((flags & KBD_FLAGS_RELEASE) == 0) && (code == RDP_SCANCODE_KEY_G)) /* 'g' key */ if (((flags & KBD_FLAGS_RELEASE) == 0) && (code == RDP_SCANCODE_KEY_G)) /* 'g' key */
{ {
if (settings->DesktopWidth != 800) if (freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) != 800)
{ {
settings->DesktopWidth = 800; if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, 800))
settings->DesktopHeight = 600; return FALSE;
if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, 600))
return FALSE;
} }
else else
{ {
settings->DesktopWidth = SAMPLE_SERVER_DEFAULT_WIDTH; if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth,
settings->DesktopHeight = SAMPLE_SERVER_DEFAULT_HEIGHT; SAMPLE_SERVER_DEFAULT_WIDTH))
return FALSE;
if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight,
SAMPLE_SERVER_DEFAULT_HEIGHT))
return FALSE;
} }
if (!rfx_context_reset(tcontext->rfx_context, settings->DesktopWidth, if (!rfx_context_reset(tcontext->rfx_context,
settings->DesktopHeight)) freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight)))
return FALSE; return FALSE;
WINPR_ASSERT(update->DesktopResize); WINPR_ASSERT(update->DesktopResize);
@ -1050,20 +1078,28 @@ static DWORD WINAPI test_peer_mainloop(LPVOID arg)
if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, cert, 1)) if (!freerdp_settings_set_pointer_len(settings, FreeRDP_RdpServerCertificate, cert, 1))
goto fail; goto fail;
settings->RdpSecurity = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, TRUE))
settings->TlsSecurity = TRUE; goto fail;
settings->NlaSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TRUE))
settings->EncryptionLevel = ENCRYPTION_LEVEL_CLIENT_COMPATIBLE; goto fail;
/* settings->EncryptionLevel = ENCRYPTION_LEVEL_HIGH; */ if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
/* settings->EncryptionLevel = ENCRYPTION_LEVEL_LOW; */ goto fail;
/* settings->EncryptionLevel = ENCRYPTION_LEVEL_FIPS; */ if (!freerdp_settings_set_uint32(settings, FreeRDP_EncryptionLevel,
settings->RemoteFxCodec = TRUE; ENCRYPTION_LEVEL_CLIENT_COMPATIBLE))
goto fail;
/* ENCRYPTION_LEVEL_HIGH; */
/* ENCRYPTION_LEVEL_LOW; */
/* ENCRYPTION_LEVEL_FIPS; */
if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec, TRUE))
goto fail;
if (!freerdp_settings_set_bool(settings, FreeRDP_NSCodec, TRUE) || if (!freerdp_settings_set_bool(settings, FreeRDP_NSCodec, TRUE) ||
!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32)) !freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
goto fail; goto fail;
settings->SuppressOutput = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE))
settings->RefreshRect = TRUE; goto fail;
if (!freerdp_settings_set_bool(settings, FreeRDP_RefreshRect, TRUE))
goto fail;
client->PostConnect = tf_peer_post_connect; client->PostConnect = tf_peer_post_connect;
client->Activate = tf_peer_activate; client->Activate = tf_peer_activate;
@ -1083,7 +1119,9 @@ static DWORD WINAPI test_peer_mainloop(LPVOID arg)
update->RefreshRect = tf_peer_refresh_rect; update->RefreshRect = tf_peer_refresh_rect;
update->SuppressOutput = tf_peer_suppress_output; update->SuppressOutput = tf_peer_suppress_output;
settings->MultifragMaxRequestSize = 0xFFFFFF; /* FIXME */ if (!freerdp_settings_set_uint32(settings, FreeRDP_MultifragMaxRequestSize,
0xFFFFFF /* FIXME */))
goto fail;
WINPR_ASSERT(client->Initialize); WINPR_ASSERT(client->Initialize);
rc = client->Initialize(client); rc = client->Initialize(client);

20
server/Windows/wf_peer.c
View File

@ -123,16 +123,17 @@ static BOOL wf_peer_post_connect(freerdp_peer* client)
return FALSE; return FALSE;
} }
if ((settings->DesktopWidth != wfi->servscreen_width) || if ((freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) != wfi->servscreen_width) ||
(settings->DesktopHeight != wfi->servscreen_height)) (freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) != wfi->servscreen_height))
{ {
/* /*
WLog_DBG(TAG, "Client requested resolution %"PRIu32"x%"PRIu32", but will resize to %dx%d", WLog_DBG(TAG, "Client requested resolution %"PRIu32"x%"PRIu32", but will resize to %dx%d",
settings->DesktopWidth, settings->DesktopHeight, wfi->servscreen_width, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight), wfi->servscreen_width,
wfi->servscreen_height); wfi->servscreen_height);
*/ */
settings->DesktopWidth = wfi->servscreen_width; freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) = wfi->servscreen_width;
settings->DesktopHeight = wfi->servscreen_height; freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) = wfi->servscreen_height;
if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, wfi->bitsPerPixel)) if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, wfi->bitsPerPixel))
return FALSE; return FALSE;
@ -284,11 +285,14 @@ DWORD WINAPI wf_peer_main_loop(LPVOID lpParam)
settings = client->context->settings; settings = client->context->settings;
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
settings->RemoteFxCodec = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec, TRUE))
goto fail_peer_init;
if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32)) if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
goto fail_peer_init; goto fail_peer_init;
settings->NSCodec = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_NSCodec, FALSE))
settings->JpegCodec = FALSE; goto fail_peer_init;
if (!freerdp_settings_set_bool(settings, FreeRDP_JpegCodec, FALSE))
goto fail_peer_init;
if (!wf_peer_read_settings(client)) if (!wf_peer_read_settings(client))
goto fail_peer_init; goto fail_peer_init;

3
server/Windows/wf_update.c
View File

@ -180,7 +180,8 @@ void wf_update_peer_send(wfInfo* wfi, wfPeerContext* context)
WINPR_ASSERT(client->context->update); WINPR_ASSERT(client->context->update);
WINPR_ASSERT(client->context->update->SurfaceBits); WINPR_ASSERT(client->context->update->SurfaceBits);
wfi->cmd.bmp.codecID = client->context->settings->RemoteFxCodecId; wfi->cmd.bmp.codecID =
freerdp_settings_get_uint32(client->context->settings, FreeRDP_RemoteFxCodecId);
client->context->update->SurfaceBits(client->context, &wfi->cmd); client->context->update->SurfaceBits(client->context, &wfi->cmd);
context->frame_idx++; context->frame_idx++;
} }

11
server/proxy/modules/capture/cap_main.c
View File

@ -162,11 +162,12 @@ static BOOL capture_plugin_send_frame(pClientContext* pc, SOCKET socket, const B
settings = pc->context.settings; settings = pc->context.settings;
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
frame_size = 1ull * settings->DesktopWidth * settings->DesktopHeight * const size_t DesktopWidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
const size_t DesktopHeight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
frame_size = DesktopWidth * DesktopHeight *
(freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth) / 8ull); (freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth) / 8ull);
bmp_header = bmp_header = winpr_bitmap_construct_header(
winpr_bitmap_construct_header(settings->DesktopWidth, settings->DesktopHeight, DesktopWidth, DesktopHeight, freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
if (!bmp_header) if (!bmp_header)
return FALSE; return FALSE;
@ -282,7 +283,7 @@ static BOOL capture_plugin_server_post_connect(proxyPlugin* plugin, proxyData* p
return FALSE; return FALSE;
} }
if (!settings->SupportGraphicsPipeline) if (!freerdp_settings_get_bool(settings, FreeRDP_SupportGraphicsPipeline))
{ {
WLog_ERR(TAG, "session capture is only supported for GFX clients, denying connection"); WLog_ERR(TAG, "session capture is only supported for GFX clients, denying connection");
return FALSE; return FALSE;

22
server/proxy/modules/capture/cap_protocol.c
View File

@ -33,31 +33,35 @@ wStream* capture_plugin_packet_new(UINT32 payload_size, UINT16 type)
wStream* capture_plugin_create_session_info_packet(pClientContext* pc) wStream* capture_plugin_create_session_info_packet(pClientContext* pc)
{ {
size_t username_length;
wStream* s = NULL; wStream* s = NULL;
rdpSettings* settings;
if (!pc) if (!pc)
return NULL; return NULL;
settings = pc->context.settings; rdpSettings* settings = pc->context.settings;
if (!settings)
if (!settings || !settings->Username)
return NULL; return NULL;
username_length = strlen(settings->Username); const char* Username = freerdp_settings_get_string(settings, FreeRDP_Username);
if (!Username)
return NULL;
const size_t username_length = strlen(Username);
if ((username_length == 0) || (username_length > UINT16_MAX)) if ((username_length == 0) || (username_length > UINT16_MAX))
return NULL; return NULL;
const UINT32 DesktopWidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
const UINT32 DesktopHeight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
s = capture_plugin_packet_new(SESSION_INFO_PDU_BASE_SIZE + (UINT32)username_length, s = capture_plugin_packet_new(SESSION_INFO_PDU_BASE_SIZE + (UINT32)username_length,
MESSAGE_TYPE_SESSION_INFO); MESSAGE_TYPE_SESSION_INFO);
if (!s) if (!s)
return NULL; return NULL;
Stream_Write_UINT16(s, (UINT16)username_length); /* username length (2 bytes) */ Stream_Write_UINT16(s, (UINT16)username_length); /* username length (2 bytes) */
Stream_Write(s, settings->Username, username_length); /* username */ Stream_Write(s, Username, username_length); /* username */
Stream_Write_UINT32(s, settings->DesktopWidth); /* desktop width (4 bytes) */ Stream_Write_UINT32(s, DesktopWidth); /* desktop width (4 bytes) */
Stream_Write_UINT32(s, settings->DesktopHeight); /* desktop height (4 bytes) */ Stream_Write_UINT32(s, DesktopHeight); /* desktop height (4 bytes) */
Stream_Write_UINT32( Stream_Write_UINT32(
s, freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth)); /* color depth (4 bytes) */ s, freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth)); /* color depth (4 bytes) */
Stream_Write(s, pc->pdata->session_id, PROXY_SESSION_ID_LENGTH); /* color depth (32 bytes) */ Stream_Write(s, pc->pdata->session_id, PROXY_SESSION_ID_LENGTH); /* color depth (32 bytes) */

74
server/proxy/pf_client.c
View File

@ -159,16 +159,8 @@ static BOOL pf_client_use_peer_load_balance_info(pClientContext* pc)
if (!lb_info) if (!lb_info)
return TRUE; return TRUE;
free(settings->LoadBalanceInfo); return freerdp_settings_set_pointer_len(settings, FreeRDP_LoadBalanceInfo, lb_info,
lb_info_len);
settings->LoadBalanceInfoLength = lb_info_len;
settings->LoadBalanceInfo = malloc(settings->LoadBalanceInfoLength);
if (!settings->LoadBalanceInfo)
return FALSE;
CopyMemory(settings->LoadBalanceInfo, lb_info, settings->LoadBalanceInfoLength);
return TRUE;
} }
static BOOL str_is_empty(const char* str) static BOOL str_is_empty(const char* str)
@ -255,14 +247,21 @@ static BOOL pf_client_pre_connect(freerdp* instance)
* *
* Also, OrderSupport need to be zeroed, because it is currently not supported. * Also, OrderSupport need to be zeroed, because it is currently not supported.
*/ */
settings->GlyphSupportLevel = GLYPH_SUPPORT_NONE; if (!freerdp_settings_set_uint32(settings, FreeRDP_GlyphSupportLevel, GLYPH_SUPPORT_NONE))
ZeroMemory(settings->OrderSupport, 32); return FALSE;
void* OrderSupport = freerdp_settings_get_pointer_writable(settings, FreeRDP_OrderSupport);
ZeroMemory(OrderSupport, 32);
if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, DRDYNVC_SVC_CHANNEL_NAME)) if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, DRDYNVC_SVC_CHANNEL_NAME))
settings->SupportDynamicChannels = TRUE; {
if (!freerdp_settings_set_bool(settings, FreeRDP_SupportDynamicChannels, TRUE))
return FALSE;
}
/* Multimon */ /* Multimon */
settings->UseMultimon = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_UseMultimon, TRUE))
return FALSE;
/* Sound */ /* Sound */
if (!freerdp_settings_set_bool(settings, FreeRDP_AudioCapture, config->AudioInput) || if (!freerdp_settings_set_bool(settings, FreeRDP_AudioCapture, config->AudioInput) ||
@ -277,29 +276,45 @@ static BOOL pf_client_pre_connect(freerdp* instance)
if (config->RemoteApp) if (config->RemoteApp)
{ {
if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, RAIL_SVC_CHANNEL_NAME)) if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, RAIL_SVC_CHANNEL_NAME))
settings->RemoteApplicationMode = TRUE; {
if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteApplicationMode, TRUE))
return FALSE;
}
} }
if (config->DeviceRedirection) if (config->DeviceRedirection)
{ {
if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, RDPDR_SVC_CHANNEL_NAME)) if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, RDPDR_SVC_CHANNEL_NAME))
settings->DeviceRedirection = TRUE; {
if (!freerdp_settings_set_bool(settings, FreeRDP_DeviceRedirection, TRUE))
return FALSE;
}
} }
/* Display control */ /* Display control */
settings->SupportDisplayControl = config->DisplayControl; if (!freerdp_settings_set_bool(settings, FreeRDP_SupportDisplayControl, config->DisplayControl))
settings->DynamicResolutionUpdate = config->DisplayControl; return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_DynamicResolutionUpdate,
config->DisplayControl))
return FALSE;
if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, ENCOMSP_SVC_CHANNEL_NAME)) if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, ENCOMSP_SVC_CHANNEL_NAME))
settings->EncomspVirtualChannel = TRUE; {
if (!freerdp_settings_set_bool(settings, FreeRDP_EncomspVirtualChannel, TRUE))
return FALSE;
}
if (config->Clipboard) if (config->Clipboard)
{ {
if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, CLIPRDR_SVC_CHANNEL_NAME)) if (WTSVirtualChannelManagerIsChannelJoined(ps->vcm, CLIPRDR_SVC_CHANNEL_NAME))
settings->RedirectClipboard = config->Clipboard; {
if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectClipboard, config->Clipboard))
return FALSE;
}
} }
settings->AutoReconnectionEnabled = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_AutoReconnectionEnabled, TRUE))
return FALSE;
PubSub_SubscribeErrorInfo(instance->context->pubSub, pf_client_on_error_info); PubSub_SubscribeErrorInfo(instance->context->pubSub, pf_client_on_error_info);
PubSub_SubscribeActivated(instance->context->pubSub, pf_client_on_activated); PubSub_SubscribeActivated(instance->context->pubSub, pf_client_on_activated);
@ -579,7 +594,7 @@ static BOOL pf_client_post_connect(freerdp* instance)
if (!gdi_init(instance, PIXEL_FORMAT_BGRA32)) if (!gdi_init(instance, PIXEL_FORMAT_BGRA32))
return FALSE; return FALSE;
WINPR_ASSERT(settings->SoftwareGdi); WINPR_ASSERT(freerdp_settings_get_bool(settings, FreeRDP_SoftwareGdi));
pf_client_register_update_callbacks(update); pf_client_register_update_callbacks(update);
@ -680,7 +695,8 @@ static BOOL pf_client_should_retry_without_nla(pClientContext* pc)
config = pc->pdata->config; config = pc->pdata->config;
WINPR_ASSERT(config); WINPR_ASSERT(config);
if (!config->ClientAllowFallbackToTls || !settings->NlaSecurity) if (!config->ClientAllowFallbackToTls ||
!freerdp_settings_get_bool(settings, FreeRDP_NlaSecurity))
return FALSE; return FALSE;
return config->ClientTlsSecurity || config->ClientRdpSecurity; return config->ClientTlsSecurity || config->ClientRdpSecurity;
@ -729,11 +745,12 @@ static BOOL pf_client_connect_without_nla(pClientContext* pc)
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
/* If already disabled abort early. */ /* If already disabled abort early. */
if (!settings->NlaSecurity) if (!freerdp_settings_get_bool(settings, FreeRDP_NlaSecurity))
return FALSE; return FALSE;
/* disable NLA */ /* disable NLA */
settings->NlaSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
return FALSE;
/* do not allow next connection failure */ /* do not allow next connection failure */
pc->allow_next_conn_failure = FALSE; pc->allow_next_conn_failure = FALSE;
@ -754,14 +771,17 @@ static BOOL pf_client_connect(freerdp* instance)
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
PROXY_LOG_INFO(TAG, pc, "connecting using client info: Username: %s, Domain: %s", PROXY_LOG_INFO(TAG, pc, "connecting using client info: Username: %s, Domain: %s",
settings->Username, settings->Domain); freerdp_settings_get_string(settings, FreeRDP_Username),
freerdp_settings_get_string(settings, FreeRDP_Domain));
pf_client_set_security_settings(pc); pf_client_set_security_settings(pc);
if (pf_client_should_retry_without_nla(pc)) if (pf_client_should_retry_without_nla(pc))
retry = pc->allow_next_conn_failure = TRUE; retry = pc->allow_next_conn_failure = TRUE;
PROXY_LOG_INFO(TAG, pc, "connecting using security settings: rdp=%d, tls=%d, nla=%d", PROXY_LOG_INFO(TAG, pc, "connecting using security settings: rdp=%d, tls=%d, nla=%d",
settings->RdpSecurity, settings->TlsSecurity, settings->NlaSecurity); freerdp_settings_get_bool(settings, FreeRDP_RdpSecurity),
freerdp_settings_get_bool(settings, FreeRDP_TlsSecurity),
freerdp_settings_get_bool(settings, FreeRDP_NlaSecurity));
if (!freerdp_connect(instance)) if (!freerdp_connect(instance))
{ {

11
server/proxy/pf_context.c
View File

@ -243,16 +243,21 @@ BOOL pf_context_copy_settings(rdpSettings* dst, const rdpSettings* src)
} }
/* keep original ServerMode value */ /* keep original ServerMode value */
dst->ServerMode = before_copy->ServerMode; if (!freerdp_settings_copy_item(dst, before_copy, FreeRDP_ServerMode))
{
freerdp_settings_free(before_copy);
return FALSE;
}
/* revert some values that must not be changed */ /* revert some values that must not be changed */
if (!pf_context_revert_str_settings(dst, before_copy, ARRAYSIZE(to_revert), to_revert)) if (!pf_context_revert_str_settings(dst, before_copy, ARRAYSIZE(to_revert), to_revert))
return FALSE; return FALSE;
if (!dst->ServerMode) if (!freerdp_settings_get_bool(dst, FreeRDP_ServerMode))
{ {
/* adjust instance pointer */ /* adjust instance pointer */
dst->instance = before_copy->instance; if (!freerdp_settings_copy_item(dst, before_copy, FreeRDP_instance))
return FALSE;
/* /*
* RdpServerRsaKey must be set to NULL if `dst` is client's context * RdpServerRsaKey must be set to NULL if `dst` is client's context

46
server/proxy/pf_server.c
View File

@ -63,8 +63,8 @@ typedef struct
freerdp_peer* client; freerdp_peer* client;
} peer_thread_args; } peer_thread_args;
static BOOL pf_server_parse_target_from_routing_token(rdpContext* context, char** target, static BOOL pf_server_parse_target_from_routing_token(rdpContext* context, rdpSettings* settings,
DWORD* port) size_t targetID, size_t portID)
{ {
#define TARGET_MAX (100) #define TARGET_MAX (100)
#define ROUTING_TOKEN_PREFIX "Cookie: msts=" #define ROUTING_TOKEN_PREFIX "Cookie: msts="
@ -85,14 +85,12 @@ static BOOL pf_server_parse_target_from_routing_token(rdpContext* context, char*
} }
len = routing_token_length - prefix_len; len = routing_token_length - prefix_len;
*target = malloc(len + 1);
if (!(*target)) if (!freerdp_settings_set_string_len(settings, targetID, routing_token + prefix_len, len))
return FALSE; return FALSE;
CopyMemory(*target, routing_token + prefix_len, len); const char* target = freerdp_settings_get_string(settings, targetID);
*(*target + len) = '\0'; colon = strchr(target, ':');
colon = strchr(*target, ':');
if (colon) if (colon)
{ {
@ -100,13 +98,10 @@ static BOOL pf_server_parse_target_from_routing_token(rdpContext* context, char*
unsigned long p = strtoul(colon + 1, NULL, 10); unsigned long p = strtoul(colon + 1, NULL, 10);
if (p > USHRT_MAX) if (p > USHRT_MAX)
{
free(*target);
return FALSE; return FALSE;
}
*port = (DWORD)p; if (!freerdp_settings_set_uint32(settings, portID, p))
*colon = '\0'; return FALSE;
} }
return TRUE; return TRUE;
@ -133,8 +128,8 @@ static BOOL pf_server_get_target_info(rdpContext* context, rdpSettings* settings
{ {
case PROXY_FETCH_TARGET_METHOD_DEFAULT: case PROXY_FETCH_TARGET_METHOD_DEFAULT:
case PROXY_FETCH_TARGET_METHOD_LOAD_BALANCE_INFO: case PROXY_FETCH_TARGET_METHOD_LOAD_BALANCE_INFO:
return pf_server_parse_target_from_routing_token(context, &settings->ServerHostname, return pf_server_parse_target_from_routing_token(
&settings->ServerPort); context, settings, FreeRDP_ServerHostname, FreeRDP_ServerPort);
case PROXY_FETCH_TARGET_METHOD_CONFIG: case PROXY_FETCH_TARGET_METHOD_CONFIG:
{ {
@ -178,8 +173,7 @@ static BOOL pf_server_get_target_info(rdpContext* context, rdpSettings* settings
} }
free(ev.target_address); free(ev.target_address);
settings->ServerPort = ev.target_port; return freerdp_settings_set_uint32(settings, FreeRDP_ServerPort, ev.target_port);
return TRUE;
} }
default: default:
PROXY_LOG_ERR(TAG, ps, "unknown target fetch method: %d", ev.fetch_method); PROXY_LOG_ERR(TAG, ps, "unknown target fetch method: %d", ev.fetch_method);
@ -284,7 +278,8 @@ static BOOL pf_server_post_connect(freerdp_peer* peer)
pdata = ps->pdata; pdata = ps->pdata;
WINPR_ASSERT(pdata); WINPR_ASSERT(pdata);
PROXY_LOG_INFO(TAG, ps, "Accepted client: %s", frontSettings->ClientHostname); const char* ClientHostname = freerdp_settings_get_string(frontSettings, FreeRDP_ClientHostname);
PROXY_LOG_INFO(TAG, ps, "Accepted client: %s", ClientHostname);
if (!pf_server_setup_channels(peer)) if (!pf_server_setup_channels(peer))
{ {
PROXY_LOG_ERR(TAG, ps, "error setting up channels"); PROXY_LOG_ERR(TAG, ps, "error setting up channels");
@ -309,8 +304,9 @@ static BOOL pf_server_post_connect(freerdp_peer* peer)
return FALSE; return FALSE;
} }
PROXY_LOG_INFO(TAG, ps, "remote target is %s:%" PRIu16 "", client_settings->ServerHostname, PROXY_LOG_INFO(TAG, ps, "remote target is %s:%" PRIu32 "",
client_settings->ServerPort); freerdp_settings_get_string(client_settings, FreeRDP_ServerHostname),
freerdp_settings_get_uint32(client_settings, FreeRDP_ServerPort));
if (!pf_modules_run_hook(pdata->module, HOOK_TYPE_SERVER_POST_CONNECT, pdata, peer)) if (!pf_modules_run_hook(pdata->module, HOOK_TYPE_SERVER_POST_CONNECT, pdata, peer))
return FALSE; return FALSE;
@ -341,7 +337,8 @@ static BOOL pf_server_activate(freerdp_peer* peer)
settings = peer->context->settings; settings = peer->context->settings;
settings->CompressionLevel = PACKET_COMPR_TYPE_RDP8; if (!freerdp_settings_set_uint32(settings, FreeRDP_CompressionLevel, PACKET_COMPR_TYPE_RDP8))
return FALSE;
if (!pf_modules_run_hook(pdata->module, HOOK_TYPE_SERVER_ACTIVATE, pdata, peer)) if (!pf_modules_run_hook(pdata->module, HOOK_TYPE_SERVER_ACTIVATE, pdata, peer))
return FALSE; return FALSE;
@ -478,7 +475,10 @@ static BOOL pf_server_initialize_peer_connection(freerdp_peer* peer)
return FALSE; return FALSE;
/* currently not supporting GDI orders */ /* currently not supporting GDI orders */
ZeroMemory(settings->OrderSupport, 32); {
void* OrderSupport = freerdp_settings_get_pointer_writable(settings, FreeRDP_OrderSupport);
ZeroMemory(OrderSupport, 32);
}
WINPR_ASSERT(peer->context->update); WINPR_ASSERT(peer->context->update);
peer->context->update->autoCalculateBitmapData = FALSE; peer->context->update->autoCalculateBitmapData = FALSE;
@ -515,7 +515,9 @@ static BOOL pf_server_initialize_peer_connection(freerdp_peer* peer)
if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, config->ServerNlaSecurity)) if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, config->ServerNlaSecurity))
return FALSE; return FALSE;
settings->EncryptionLevel = ENCRYPTION_LEVEL_CLIENT_COMPATIBLE; if (!freerdp_settings_set_uint32(settings, FreeRDP_EncryptionLevel,
ENCRYPTION_LEVEL_CLIENT_COMPATIBLE))
return FALSE;
if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32)) if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
return FALSE; return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE)) if (!freerdp_settings_set_bool(settings, FreeRDP_SuppressOutput, TRUE))

6
server/proxy/pf_update.c
View File

@ -144,8 +144,10 @@ static BOOL pf_client_desktop_resize(rdpContext* context)
WINPR_ASSERT(context->settings); WINPR_ASSERT(context->settings);
WINPR_ASSERT(ps->settings); WINPR_ASSERT(ps->settings);
WLog_DBG(TAG, "called"); WLog_DBG(TAG, "called");
ps->settings->DesktopWidth = context->settings->DesktopWidth; if (!freerdp_settings_copy_item(ps->settings, context->settings, FreeRDP_DesktopWidth))
ps->settings->DesktopHeight = context->settings->DesktopHeight; return FALSE;
if (!freerdp_settings_copy_item(ps->settings, context->settings, FreeRDP_DesktopHeight))
return FALSE;
return ps->update->DesktopResize(ps); return ps->update->DesktopResize(ps);
} }

104
server/shadow/Win/win_rdp.c
View File

@ -290,45 +290,79 @@ static BOOL shw_freerdp_client_new(freerdp* instance, rdpContext* context)
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
shw->settings = settings; shw->settings = settings;
settings->AsyncChannels = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_AsyncChannels, FALSE))
settings->AsyncUpdate = FALSE; return FALSE;
settings->IgnoreCertificate = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_AsyncUpdate, FALSE))
settings->ExternalCertificateManagement = TRUE; return FALSE;
settings->RdpSecurity = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_IgnoreCertificate, TRUE))
settings->TlsSecurity = TRUE; return FALSE;
settings->NlaSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_ExternalCertificateManagement, TRUE))
settings->BitmapCacheEnabled = FALSE; return FALSE;
settings->BitmapCacheV3Enabled = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, TRUE))
settings->OffscreenSupportLevel = FALSE; return FALSE;
settings->GlyphSupportLevel = GLYPH_SUPPORT_NONE; if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TRUE))
settings->BrushSupportLevel = FALSE; return FALSE;
ZeroMemory(settings->OrderSupport, 32); if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
settings->FrameMarkerCommandEnabled = TRUE; return FALSE;
settings->SurfaceFrameMarkerEnabled = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_BitmapCacheEnabled, FALSE))
settings->AltSecFrameMarkerSupport = TRUE; return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_BitmapCacheV3Enabled, FALSE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_OffscreenSupportLevel, FALSE))
return FALSE;
if (!freerdp_settings_set_uint32(settings, FreeRDP_GlyphSupportLevel, GLYPH_SUPPORT_NONE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_BrushSupportLevel, FALSE))
return FALSE;
ZeroMemory(freerdp_settings_get_pointer_writeable(settings, FreeRDP_OrderSupport), 32);
if (!freerdp_settings_set_bool(settings, FreeRDP_FrameMarkerCommandEnabled, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_SurfaceFrameMarkerEnabled, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_AltSecFrameMarkerSupport, TRUE))
return FALSE;
if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32)) if (!freerdp_settings_set_uint32(settings, FreeRDP_ColorDepth, 32))
return FALSE; return FALSE;
settings->NSCodec = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_NSCodec, TRUE))
settings->RemoteFxCodec = TRUE; return FALSE;
settings->FastPathInput = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec, TRUE))
settings->FastPathOutput = TRUE; return FALSE;
settings->LargePointerFlag = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_FastPathInput, TRUE))
settings->CompressionEnabled = FALSE; return FALSE;
settings->AutoReconnectionEnabled = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_FastPathOutput, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_LargePointerFlag, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_CompressionEnabled, FALSE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_AutoReconnectionEnabled, FALSE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_NetworkAutoDetect, FALSE)) if (!freerdp_settings_set_bool(settings, FreeRDP_NetworkAutoDetect, FALSE))
return FALSE; return FALSE;
settings->SupportHeartbeatPdu = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_SupportHeartbeatPdu, FALSE))
settings->SupportMultitransport = FALSE; return FALSE;
settings->ConnectionType = CONNECTION_TYPE_LAN; if (!freerdp_settings_set_bool(settings, FreeRDP_SupportMultitransport, FALSE))
settings->AllowFontSmoothing = TRUE; return FALSE;
settings->AllowDesktopComposition = TRUE; if (!freerdp_settings_set_uint32(settings, FreeRDP_ConnectionType, CONNECTION_TYPE_LAN))
settings->DisableWallpaper = FALSE; return FALSE;
settings->DisableFullWindowDrag = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_AllowFontSmoothing, TRUE))
settings->DisableMenuAnims = TRUE; return FALSE;
settings->DisableThemes = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_AllowDesktopComposition, TRUE))
settings->DeviceRedirection = TRUE; return FALSE;
settings->RedirectClipboard = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_DisableWallpaper, FALSE))
settings->SupportDynamicChannels = TRUE; return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_DisableFullWindowDrag, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_DisableMenuAnims, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_DisableThemes, FALSE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_DeviceRedirection, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_RedirectClipboard, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_SupportDynamicChannels, TRUE))
return FALSE;
return TRUE; return TRUE;
} }

4
server/shadow/shadow_channels.c
View File

@ -41,7 +41,7 @@ UINT shadow_client_channels_post_connect(rdpShadowClient* client)
shadow_client_audin_init(client); shadow_client_audin_init(client);
if (client->context.settings->SupportGraphicsPipeline) if (freerdp_settings_get_bool(client->context.settings, FreeRDP_SupportGraphicsPipeline))
{ {
shadow_client_rdpgfx_init(client); shadow_client_rdpgfx_init(client);
} }
@ -51,7 +51,7 @@ UINT shadow_client_channels_post_connect(rdpShadowClient* client)
void shadow_client_channels_free(rdpShadowClient* client) void shadow_client_channels_free(rdpShadowClient* client)
{ {
if (client->context.settings->SupportGraphicsPipeline) if (freerdp_settings_get_bool(client->context.settings, FreeRDP_SupportGraphicsPipeline))
{ {
shadow_client_rdpgfx_uninit(client); shadow_client_rdpgfx_uninit(client);
} }

172
server/shadow/shadow_client.c
View File

@ -56,10 +56,10 @@ static INLINE BOOL shadow_client_rdpgfx_new_surface(rdpShadowClient* client)
settings = ((rdpContext*)client)->settings; settings = ((rdpContext*)client)->settings;
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
WINPR_ASSERT(settings->DesktopWidth <= UINT16_MAX); WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) <= UINT16_MAX);
WINPR_ASSERT(settings->DesktopHeight <= UINT16_MAX); WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) <= UINT16_MAX);
createSurface.width = (UINT16)settings->DesktopWidth; createSurface.width = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
createSurface.height = (UINT16)settings->DesktopHeight; createSurface.height = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
createSurface.pixelFormat = GFX_PIXEL_FORMAT_XRGB_8888; createSurface.pixelFormat = GFX_PIXEL_FORMAT_XRGB_8888;
createSurface.surfaceId = client->surfaceId; createSurface.surfaceId = client->surfaceId;
surfaceToOutput.outputOriginX = 0; surfaceToOutput.outputOriginX = 0;
@ -124,8 +124,8 @@ static INLINE BOOL shadow_client_rdpgfx_reset_graphic(rdpShadowClient* client)
settings = client->context.settings; settings = client->context.settings;
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
pdu.width = settings->DesktopWidth; pdu.width = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
pdu.height = settings->DesktopHeight; pdu.height = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
pdu.monitorCount = client->subsystem->numMonitors; pdu.monitorCount = client->subsystem->numMonitors;
pdu.monitorDefArray = client->subsystem->monitors; pdu.monitorDefArray = client->subsystem->monitors;
IFCALLRET(context->ResetGraphics, error, context, &pdu); IFCALLRET(context->ResetGraphics, error, context, &pdu);
@ -210,23 +210,38 @@ static BOOL shadow_client_context_new(freerdp_peer* peer, rdpContext* context)
freerdp_settings_get_uint32(srvSettings, FreeRDP_ColorDepth))) freerdp_settings_get_uint32(srvSettings, FreeRDP_ColorDepth)))
return FALSE; return FALSE;
NSCodec = freerdp_settings_get_bool(srvSettings, FreeRDP_NSCodec); NSCodec = freerdp_settings_get_bool(srvSettings, FreeRDP_NSCodec);
freerdp_settings_set_bool(settings, FreeRDP_NSCodec, NSCodec); if (!freerdp_settings_set_bool(settings, FreeRDP_NSCodec, NSCodec))
settings->RemoteFxCodec = srvSettings->RemoteFxCodec; return FALSE;
settings->BitmapCacheV3Enabled = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_RemoteFxCodec,
settings->FrameMarkerCommandEnabled = TRUE; freerdp_settings_get_bool(srvSettings, FreeRDP_RemoteFxCodec)))
settings->SurfaceFrameMarkerEnabled = TRUE; return FALSE;
settings->SupportGraphicsPipeline = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_BitmapCacheV3Enabled, TRUE))
settings->GfxH264 = srvSettings->GfxH264; return FALSE;
settings->DrawAllowSkipAlpha = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_FrameMarkerCommandEnabled, TRUE))
settings->DrawAllowColorSubsampling = TRUE; return FALSE;
settings->DrawAllowDynamicColorFidelity = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_SurfaceFrameMarkerEnabled, TRUE))
settings->CompressionLevel = PACKET_COMPR_TYPE_RDP8; return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_SupportGraphicsPipeline, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_GfxH264,
freerdp_settings_get_bool(srvSettings, FreeRDP_GfxH264)))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_DrawAllowSkipAlpha, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_DrawAllowColorSubsampling, TRUE))
return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_DrawAllowDynamicColorFidelity, TRUE))
return FALSE;
if (!freerdp_settings_set_uint32(settings, FreeRDP_CompressionLevel, PACKET_COMPR_TYPE_RDP8))
return FALSE;
if (server->ipcSocket && (strncmp(bind_address, server->ipcSocket, if (server->ipcSocket && (strncmp(bind_address, server->ipcSocket,
strnlen(bind_address, sizeof(bind_address))) != 0)) strnlen(bind_address, sizeof(bind_address))) != 0))
{ {
settings->LyncRdpMode = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_LyncRdpMode, TRUE))
settings->CompressionEnabled = FALSE; return FALSE;
if (!freerdp_settings_set_bool(settings, FreeRDP_CompressionEnabled, FALSE))
return FALSE;
} }
client->inLobby = TRUE; client->inLobby = TRUE;
@ -285,10 +300,10 @@ static INLINE void shadow_client_mark_invalid(rdpShadowClient* client, UINT32 nu
{ {
screenRegion.left = 0; screenRegion.left = 0;
screenRegion.top = 0; screenRegion.top = 0;
WINPR_ASSERT(settings->DesktopWidth <= UINT16_MAX); WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) <= UINT16_MAX);
WINPR_ASSERT(settings->DesktopHeight <= UINT16_MAX); WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) <= UINT16_MAX);
screenRegion.right = (UINT16)settings->DesktopWidth; screenRegion.right = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
screenRegion.bottom = (UINT16)settings->DesktopHeight; screenRegion.bottom = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
region16_union_rect(&(client->invalidRegion), &(client->invalidRegion), &screenRegion); region16_union_rect(&(client->invalidRegion), &(client->invalidRegion), &screenRegion);
} }
@ -333,7 +348,8 @@ static INLINE BOOL shadow_client_recalc_desktop_size(rdpShadowClient* client)
WINPR_ASSERT(width <= UINT16_MAX); WINPR_ASSERT(width <= UINT16_MAX);
WINPR_ASSERT(height >= 0); WINPR_ASSERT(height >= 0);
WINPR_ASSERT(height <= UINT16_MAX); WINPR_ASSERT(height <= UINT16_MAX);
if (settings->DesktopWidth != (UINT32)width || settings->DesktopHeight != (UINT32)height) if (freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) != (UINT32)width ||
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) != (UINT32)height)
return TRUE; return TRUE;
return FALSE; return FALSE;
@ -449,7 +465,9 @@ static BOOL shadow_client_post_connect(freerdp_peer* peer)
return FALSE; return FALSE;
} }
if (settings->MultifragMaxRequestSize < 0x3F0000) const UINT32 MultifragMaxRequestSize =
freerdp_settings_get_uint32(settings, FreeRDP_MultifragMaxRequestSize);
if (MultifragMaxRequestSize < 0x3F0000)
{ {
BOOL rc = freerdp_settings_set_bool( BOOL rc = freerdp_settings_set_bool(
settings, FreeRDP_NSCodec, settings, FreeRDP_NSCodec,
@ -458,7 +476,8 @@ static BOOL shadow_client_post_connect(freerdp_peer* peer)
} }
WLog_INFO(TAG, "Client from %s is activated (%" PRIu32 "x%" PRIu32 "@%" PRIu32 ")", WLog_INFO(TAG, "Client from %s is activated (%" PRIu32 "x%" PRIu32 "@%" PRIu32 ")",
peer->hostname, settings->DesktopWidth, settings->DesktopHeight, peer->hostname, freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight),
freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth)); freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth));
if (shadow_client_channels_post_connect(client) != CHANNEL_RC_OK) if (shadow_client_channels_post_connect(client) != CHANNEL_RC_OK)
@ -467,15 +486,21 @@ static BOOL shadow_client_post_connect(freerdp_peer* peer)
shadow_client_mark_invalid(client, 0, NULL); shadow_client_mark_invalid(client, 0, NULL);
authStatus = -1; authStatus = -1;
if (settings->Username && settings->Password) const char* Username = freerdp_settings_get_string(settings, FreeRDP_Username);
settings->AutoLogonEnabled = TRUE; const char* Domain = freerdp_settings_get_string(settings, FreeRDP_Domain);
const char* Password = freerdp_settings_get_string(settings, FreeRDP_Password);
if (server->authentication && !settings->NlaSecurity) if (Username && Password)
{
if (!freerdp_settings_set_bool(settings, FreeRDP_AutoLogonEnabled, TRUE))
return FALSE;
}
if (server->authentication && !freerdp_settings_get_bool(settings, FreeRDP_NlaSecurity))
{ {
if (subsystem->Authenticate) if (subsystem->Authenticate)
{ {
authStatus = subsystem->Authenticate(subsystem, client, settings->Username, authStatus = subsystem->Authenticate(subsystem, client, Username, Domain, Password);
settings->Domain, settings->Password);
} }
if (authStatus < 0) if (authStatus < 0)
@ -744,19 +769,17 @@ shadow_client_rdpgfx_frame_acknowledge(RdpgfxServerContext* context,
static BOOL shadow_are_caps_filtered(const rdpSettings* settings, UINT32 caps) static BOOL shadow_are_caps_filtered(const rdpSettings* settings, UINT32 caps)
{ {
UINT32 filter;
const UINT32 capList[] = { RDPGFX_CAPVERSION_8, RDPGFX_CAPVERSION_81, const UINT32 capList[] = { RDPGFX_CAPVERSION_8, RDPGFX_CAPVERSION_81,
RDPGFX_CAPVERSION_10, RDPGFX_CAPVERSION_101, RDPGFX_CAPVERSION_10, RDPGFX_CAPVERSION_101,
RDPGFX_CAPVERSION_102, RDPGFX_CAPVERSION_103, RDPGFX_CAPVERSION_102, RDPGFX_CAPVERSION_103,
RDPGFX_CAPVERSION_104, RDPGFX_CAPVERSION_105, RDPGFX_CAPVERSION_104, RDPGFX_CAPVERSION_105,
RDPGFX_CAPVERSION_106, RDPGFX_CAPVERSION_106_ERR, RDPGFX_CAPVERSION_106, RDPGFX_CAPVERSION_106_ERR,
RDPGFX_CAPVERSION_107 }; RDPGFX_CAPVERSION_107 };
UINT32 x;
WINPR_ASSERT(settings); WINPR_ASSERT(settings);
filter = settings->GfxCapsFilter; const UINT32 filter = freerdp_settings_get_uint32(settings, FreeRDP_GfxCapsFilter);
for (x = 0; x < ARRAYSIZE(capList); x++) for (UINT32 x = 0; x < ARRAYSIZE(capList); x++)
{ {
if (caps == capList[x]) if (caps == capList[x])
return (filter & (1 << x)) != 0; return (filter & (1 << x)) != 0;
@ -818,29 +841,38 @@ static BOOL shadow_client_caps_test_version(RdpgfxServerContext* context, rdpSha
flags = pdu.capsSet->flags; flags = pdu.capsSet->flags;
clientSettings->GfxSmallCache = (flags & RDPGFX_CAPS_FLAG_SMALL_CACHE) ? TRUE : FALSE; if (!freerdp_settings_set_bool(clientSettings, FreeRDP_GfxSmallCache,
(flags & RDPGFX_CAPS_FLAG_SMALL_CACHE) ? TRUE : FALSE))
return FALSE;
avc444v2 = avc444 = !(flags & RDPGFX_CAPS_FLAG_AVC_DISABLED); avc444v2 = avc444 = !(flags & RDPGFX_CAPS_FLAG_AVC_DISABLED);
if (!freerdp_settings_get_bool(srvSettings, FreeRDP_GfxAVC444v2) || !h264) if (!freerdp_settings_get_bool(srvSettings, FreeRDP_GfxAVC444v2) || !h264)
avc444v2 = FALSE; avc444v2 = FALSE;
freerdp_settings_set_bool(clientSettings, FreeRDP_GfxAVC444v2, avc444v2); if (!freerdp_settings_set_bool(clientSettings, FreeRDP_GfxAVC444v2, avc444v2))
return FALSE;
if (!freerdp_settings_get_bool(srvSettings, FreeRDP_GfxAVC444) || !h264) if (!freerdp_settings_get_bool(srvSettings, FreeRDP_GfxAVC444) || !h264)
avc444 = FALSE; avc444 = FALSE;
freerdp_settings_set_bool(clientSettings, FreeRDP_GfxAVC444, avc444); if (!freerdp_settings_set_bool(clientSettings, FreeRDP_GfxAVC444, avc444))
return FALSE;
if (!freerdp_settings_get_bool(srvSettings, FreeRDP_GfxH264) || !h264) if (!freerdp_settings_get_bool(srvSettings, FreeRDP_GfxH264) || !h264)
avc420 = FALSE; avc420 = FALSE;
freerdp_settings_set_bool(clientSettings, FreeRDP_GfxH264, avc420); if (!freerdp_settings_set_bool(clientSettings, FreeRDP_GfxH264, avc420))
return FALSE;
progressive = freerdp_settings_get_bool(srvSettings, FreeRDP_GfxProgressive); progressive = freerdp_settings_get_bool(srvSettings, FreeRDP_GfxProgressive);
freerdp_settings_set_bool(clientSettings, FreeRDP_GfxProgressive, progressive); if (!freerdp_settings_set_bool(clientSettings, FreeRDP_GfxProgressive, progressive))
return FALSE;
progressive = freerdp_settings_get_bool(srvSettings, FreeRDP_GfxProgressiveV2); progressive = freerdp_settings_get_bool(srvSettings, FreeRDP_GfxProgressiveV2);
freerdp_settings_set_bool(clientSettings, FreeRDP_GfxProgressiveV2, progressive); if (!freerdp_settings_set_bool(clientSettings, FreeRDP_GfxProgressiveV2, progressive))
return FALSE;
rfx = freerdp_settings_get_bool(srvSettings, FreeRDP_RemoteFxCodec); rfx = freerdp_settings_get_bool(srvSettings, FreeRDP_RemoteFxCodec);
freerdp_settings_set_bool(clientSettings, FreeRDP_RemoteFxCodec, rfx); if (!freerdp_settings_set_bool(clientSettings, FreeRDP_RemoteFxCodec, rfx))
return FALSE;
planar = freerdp_settings_get_bool(srvSettings, FreeRDP_GfxPlanar); planar = freerdp_settings_get_bool(srvSettings, FreeRDP_GfxPlanar);
freerdp_settings_set_bool(clientSettings, FreeRDP_GfxPlanar, planar); if (!freerdp_settings_set_bool(clientSettings, FreeRDP_GfxPlanar, planar))
return FALSE;
if (!avc444v2 && !avc444 && !avc420) if (!avc444v2 && !avc444 && !avc420)
pdu.capsSet->flags |= RDPGFX_CAPS_FLAG_AVC_DISABLED; pdu.capsSet->flags |= RDPGFX_CAPS_FLAG_AVC_DISABLED;
@ -1063,12 +1095,15 @@ static BOOL shadow_client_send_surface_gfx(rdpShadowClient* client, const BYTE*
id = freerdp_settings_get_uint32(settings, FreeRDP_RemoteFxCodecId); id = freerdp_settings_get_uint32(settings, FreeRDP_RemoteFxCodecId);
#ifdef WITH_GFX_H264 #ifdef WITH_GFX_H264
if (settings->GfxAVC444 || settings->GfxAVC444v2) const BOOL GfxH264 = freerdp_settings_get_bool(settings, FreeRDP_GfxH264);
const BOOL GfxAVC444 = freerdp_settings_get_bool(settings, FreeRDP_GfxAVC444);
const BOOL GfxAVC444v2 = freerdp_settings_get_bool(settings, FreeRDP_GfxAVC444v2);
if (GfxAVC444 || GfxAVC444v2)
{ {
INT32 rc; INT32 rc;
RDPGFX_AVC444_BITMAP_STREAM avc444 = { 0 }; RDPGFX_AVC444_BITMAP_STREAM avc444 = { 0 };
RECTANGLE_16 regionRect = { 0 }; RECTANGLE_16 regionRect = { 0 };
BYTE version = settings->GfxAVC444v2 ? 2 : 1; BYTE version = GfxAVC444v2 ? 2 : 1;
if (shadow_encoder_prepare(encoder, FREERDP_CODEC_AVC444) < 0) if (shadow_encoder_prepare(encoder, FREERDP_CODEC_AVC444) < 0)
{ {
@ -1099,7 +1134,7 @@ static BOOL shadow_client_send_surface_gfx(rdpShadowClient* client, const BYTE*
if (rc > 0) if (rc > 0)
{ {
avc444.cbAvc420EncodedBitstream1 = rdpgfx_estimate_h264_avc420(&avc444.bitstream[0]); avc444.cbAvc420EncodedBitstream1 = rdpgfx_estimate_h264_avc420(&avc444.bitstream[0]);
cmd.codecId = settings->GfxAVC444v2 ? RDPGFX_CODECID_AVC444v2 : RDPGFX_CODECID_AVC444; cmd.codecId = GfxAVC444v2 ? RDPGFX_CODECID_AVC444v2 : RDPGFX_CODECID_AVC444;
cmd.extra = (void*)&avc444; cmd.extra = (void*)&avc444;
IFCALLRET(client->rdpgfx->SurfaceFrameCommand, error, client->rdpgfx, &cmd, &cmdstart, IFCALLRET(client->rdpgfx->SurfaceFrameCommand, error, client->rdpgfx, &cmd, &cmdstart,
&cmdend); &cmdend);
@ -1113,7 +1148,7 @@ static BOOL shadow_client_send_surface_gfx(rdpShadowClient* client, const BYTE*
return FALSE; return FALSE;
} }
} }
else if (settings->GfxH264) else if (GfxH264)
{ {
INT32 rc; INT32 rc;
RDPGFX_AVC420_BITMAP_STREAM avc420 = { 0 }; RDPGFX_AVC420_BITMAP_STREAM avc420 = { 0 };
@ -1375,9 +1410,13 @@ static BOOL shadow_client_send_surface_bits(rdpShadowClient* client, BYTE* pSrcD
rect.width = nWidth; rect.width = nWidth;
rect.height = nHeight; rect.height = nHeight;
RFX_MESSAGE_LIST* messages = rfx_encode_messages( const UINT32 MultifragMaxRequestSize =
encoder->rfx, &rect, 1, pSrcData, settings->DesktopWidth, settings->DesktopHeight, freerdp_settings_get_uint32(settings, FreeRDP_MultifragMaxRequestSize);
nSrcStep, &numMessages, settings->MultifragMaxRequestSize); RFX_MESSAGE_LIST* messages =
rfx_encode_messages(encoder->rfx, &rect, 1, pSrcData,
freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth),
freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight),
nSrcStep, &numMessages, MultifragMaxRequestSize);
if (!messages) if (!messages)
{ {
WLog_ERR(TAG, "rfx_encode_messages failed"); WLog_ERR(TAG, "rfx_encode_messages failed");
@ -1389,14 +1428,14 @@ static BOOL shadow_client_send_surface_bits(rdpShadowClient* client, BYTE* pSrcD
cmd.bmp.codecID = (UINT16)rfxID; cmd.bmp.codecID = (UINT16)rfxID;
cmd.destLeft = 0; cmd.destLeft = 0;
cmd.destTop = 0; cmd.destTop = 0;
cmd.destRight = settings->DesktopWidth; cmd.destRight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
cmd.destBottom = settings->DesktopHeight; cmd.destBottom = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
cmd.bmp.bpp = 32; cmd.bmp.bpp = 32;
cmd.bmp.flags = 0; cmd.bmp.flags = 0;
WINPR_ASSERT(settings->DesktopWidth <= UINT16_MAX); WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth) <= UINT16_MAX);
WINPR_ASSERT(settings->DesktopHeight <= UINT16_MAX); WINPR_ASSERT(freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight) <= UINT16_MAX);
cmd.bmp.width = (UINT16)settings->DesktopWidth; cmd.bmp.width = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
cmd.bmp.height = (UINT16)settings->DesktopHeight; cmd.bmp.height = (UINT16)freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
cmd.skipCompression = TRUE; cmd.skipCompression = TRUE;
for (size_t i = 0; i < numMessages; i++) for (size_t i = 0; i < numMessages; i++)
@ -1496,7 +1535,6 @@ static BOOL shadow_client_send_bitmap_update(rdpShadowClient* client, BYTE* pSrc
rdpUpdate* update; rdpUpdate* update;
rdpContext* context = (rdpContext*)client; rdpContext* context = (rdpContext*)client;
rdpSettings* settings; rdpSettings* settings;
UINT32 maxUpdateSize;
UINT32 totalBitmapSize; UINT32 totalBitmapSize;
UINT32 updateSizeEstimate; UINT32 updateSizeEstimate;
BITMAP_DATA* bitmapData; BITMAP_DATA* bitmapData;
@ -1513,8 +1551,8 @@ static BOOL shadow_client_send_bitmap_update(rdpShadowClient* client, BYTE* pSrc
if (!update || !settings || !encoder) if (!update || !settings || !encoder)
return FALSE; return FALSE;
maxUpdateSize = settings->MultifragMaxRequestSize; const UINT32 maxUpdateSize =
freerdp_settings_get_uint32(settings, FreeRDP_MultifragMaxRequestSize);
if (freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth) < 32) if (freerdp_settings_get_uint32(settings, FreeRDP_ColorDepth) < 32)
{ {
if (shadow_encoder_prepare(encoder, FREERDP_CODEC_INTERLEAVED) < 0) if (shadow_encoder_prepare(encoder, FREERDP_CODEC_INTERLEAVED) < 0)
@ -1791,13 +1829,13 @@ static BOOL shadow_client_send_surface_update(rdpShadowClient* client, SHADOW_GF
// PRId64 " height: %" PRId64 " right: %" PRId64 " bottom: %" PRId64, nXSrc, nYSrc, nWidth, // PRId64 " height: %" PRId64 " right: %" PRId64 " bottom: %" PRId64, nXSrc, nYSrc, nWidth,
// nHeight, nXSrc + nWidth, nYSrc + nHeight); // nHeight, nXSrc + nWidth, nYSrc + nHeight);
if (settings->SupportGraphicsPipeline) if (freerdp_settings_get_bool(settings, FreeRDP_SupportGraphicsPipeline))
{ {
if (pStatus->gfxOpened) if (pStatus->gfxOpened)
{ {
/* GFX/h264 always full screen encoded */ /* GFX/h264 always full screen encoded */
nWidth = settings->DesktopWidth; nWidth = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
nHeight = settings->DesktopHeight; nHeight = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
/* Create primary surface if have not */ /* Create primary surface if have not */
if (!pStatus->gfxSurfaceCreated) if (!pStatus->gfxSurfaceCreated)
@ -1824,7 +1862,8 @@ static BOOL shadow_client_send_surface_update(rdpShadowClient* client, SHADOW_GF
ret = TRUE; ret = TRUE;
} }
} }
else if (settings->RemoteFxCodec || freerdp_settings_get_bool(settings, FreeRDP_NSCodec)) else if (freerdp_settings_get_bool(settings, FreeRDP_RemoteFxCodec) ||
freerdp_settings_get_bool(settings, FreeRDP_NSCodec))
{ {
WINPR_ASSERT(nXSrc >= 0); WINPR_ASSERT(nXSrc >= 0);
WINPR_ASSERT(nXSrc <= UINT16_MAX); WINPR_ASSERT(nXSrc <= UINT16_MAX);
@ -2247,7 +2286,8 @@ static DWORD WINAPI shadow_client_thread(LPVOID arg)
#endif #endif
/* Init RDPGFX dynamic channel */ /* Init RDPGFX dynamic channel */
if (settings->SupportGraphicsPipeline && client->rdpgfx && !gfxstatus.gfxOpened) if (freerdp_settings_get_bool(settings, FreeRDP_SupportGraphicsPipeline) &&
client->rdpgfx && !gfxstatus.gfxOpened)
{ {
client->rdpgfx->FrameAcknowledge = shadow_client_rdpgfx_frame_acknowledge; client->rdpgfx->FrameAcknowledge = shadow_client_rdpgfx_frame_acknowledge;
client->rdpgfx->CapsAdvertise = shadow_client_rdpgfx_caps_advertise; client->rdpgfx->CapsAdvertise = shadow_client_rdpgfx_caps_advertise;
@ -2255,7 +2295,9 @@ static DWORD WINAPI shadow_client_thread(LPVOID arg)
if (!client->rdpgfx->Open(client->rdpgfx)) if (!client->rdpgfx->Open(client->rdpgfx))
{ {
WLog_WARN(TAG, "Failed to open GraphicsPipeline"); WLog_WARN(TAG, "Failed to open GraphicsPipeline");
settings->SupportGraphicsPipeline = FALSE; if (!freerdp_settings_set_bool(settings,
FreeRDP_SupportGraphicsPipeline, FALSE))
goto fail;
} }
else else
{ {

22
server/shadow/shadow_encoder.c
View File

@ -132,7 +132,8 @@ static int shadow_encoder_uninit_grid(rdpShadowEncoder* encoder)
static int shadow_encoder_init_rfx(rdpShadowEncoder* encoder) static int shadow_encoder_init_rfx(rdpShadowEncoder* encoder)
{ {
if (!encoder->rfx) if (!encoder->rfx)
encoder->rfx = rfx_context_new_ex(TRUE, encoder->server->settings->ThreadingFlags); encoder->rfx = rfx_context_new_ex(
TRUE, freerdp_settings_get_uint32(encoder->server->settings, FreeRDP_ThreadingFlags));
if (!encoder->rfx) if (!encoder->rfx)
goto fail; goto fail;
@ -163,14 +164,17 @@ static int shadow_encoder_init_nsc(rdpShadowEncoder* encoder)
if (!nsc_context_reset(encoder->nsc, encoder->width, encoder->height)) if (!nsc_context_reset(encoder->nsc, encoder->width, encoder->height))
goto fail; goto fail;
if (!nsc_context_set_parameters(encoder->nsc, NSC_COLOR_LOSS_LEVEL, if (!nsc_context_set_parameters(
settings->NSCodecColorLossLevel)) encoder->nsc, NSC_COLOR_LOSS_LEVEL,
freerdp_settings_get_uint32(settings, FreeRDP_NSCodecColorLossLevel)))
goto fail; goto fail;
if (!nsc_context_set_parameters(encoder->nsc, NSC_ALLOW_SUBSAMPLING, if (!nsc_context_set_parameters(
(UINT32)settings->NSCodecAllowSubsampling)) encoder->nsc, NSC_ALLOW_SUBSAMPLING,
freerdp_settings_get_bool(settings, FreeRDP_NSCodecAllowSubsampling)))
goto fail; goto fail;
if (!nsc_context_set_parameters(encoder->nsc, NSC_DYNAMIC_COLOR_FIDELITY, if (!nsc_context_set_parameters(
(UINT32)settings->NSCodecAllowDynamicColorFidelity)) encoder->nsc, NSC_DYNAMIC_COLOR_FIDELITY,
!freerdp_settings_get_bool(settings, FreeRDP_NSCodecAllowDynamicColorFidelity)))
goto fail; goto fail;
if (!nsc_context_set_parameters(encoder->nsc, NSC_COLOR_FORMAT, PIXEL_FORMAT_BGRX32)) if (!nsc_context_set_parameters(encoder->nsc, NSC_COLOR_FORMAT, PIXEL_FORMAT_BGRX32))
goto fail; goto fail;
@ -187,7 +191,7 @@ static int shadow_encoder_init_planar(rdpShadowEncoder* encoder)
rdpContext* context = (rdpContext*)encoder->client; rdpContext* context = (rdpContext*)encoder->client;
rdpSettings* settings = context->settings; rdpSettings* settings = context->settings;
if (settings->DrawAllowSkipAlpha) if (freerdp_settings_get_bool(settings, FreeRDP_DrawAllowSkipAlpha))
planarFlags |= PLANAR_FORMAT_HEADER_NA; planarFlags |= PLANAR_FORMAT_HEADER_NA;
planarFlags |= PLANAR_FORMAT_HEADER_RLE; planarFlags |= PLANAR_FORMAT_HEADER_RLE;
@ -418,7 +422,7 @@ int shadow_encoder_reset(rdpShadowEncoder* encoder)
encoder->maxFps = 32; encoder->maxFps = 32;
encoder->frameId = 0; encoder->frameId = 0;
encoder->lastAckframeId = 0; encoder->lastAckframeId = 0;
encoder->frameAck = settings->SurfaceFrameMarkerEnabled; encoder->frameAck = freerdp_settings_get_bool(settings, FreeRDP_SurfaceFrameMarkerEnabled);
return 1; return 1;
} }

67
server/shadow/shadow_server.c
View File

@ -311,32 +311,49 @@ int shadow_server_parse_command_line(rdpShadowServer* server, int argc, char** a
{ {
if (strcmp("rdp", arg->Value) == 0) /* Standard RDP */ if (strcmp("rdp", arg->Value) == 0) /* Standard RDP */
{ {
settings->RdpSecurity = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, TRUE))
settings->TlsSecurity = FALSE; return COMMAND_LINE_ERROR;
settings->NlaSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, FALSE))
settings->ExtSecurity = FALSE; return COMMAND_LINE_ERROR;
settings->UseRdpSecurityLayer = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
return COMMAND_LINE_ERROR;
if (!freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity, FALSE))
return COMMAND_LINE_ERROR;
if (!freerdp_settings_set_bool(settings, FreeRDP_UseRdpSecurityLayer, TRUE))
return COMMAND_LINE_ERROR;
} }
else if (strcmp("tls", arg->Value) == 0) /* TLS */ else if (strcmp("tls", arg->Value) == 0) /* TLS */
{ {
settings->RdpSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, FALSE))
settings->TlsSecurity = TRUE; return COMMAND_LINE_ERROR;
settings->NlaSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, TRUE))
settings->ExtSecurity = FALSE; return COMMAND_LINE_ERROR;
if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
return COMMAND_LINE_ERROR;
if (!freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity, FALSE))
return COMMAND_LINE_ERROR;
} }
else if (strcmp("nla", arg->Value) == 0) /* NLA */ else if (strcmp("nla", arg->Value) == 0) /* NLA */
{ {
settings->RdpSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, FALSE))
settings->TlsSecurity = FALSE; return COMMAND_LINE_ERROR;
settings->NlaSecurity = TRUE; if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, FALSE))
settings->ExtSecurity = FALSE; return COMMAND_LINE_ERROR;
if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, TRUE))
return COMMAND_LINE_ERROR;
if (!freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity, FALSE))
return COMMAND_LINE_ERROR;
} }
else if (strcmp("ext", arg->Value) == 0) /* NLA Extended */ else if (strcmp("ext", arg->Value) == 0) /* NLA Extended */
{ {
settings->RdpSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity, FALSE))
settings->TlsSecurity = FALSE; return COMMAND_LINE_ERROR;
settings->NlaSecurity = FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity, FALSE))
settings->ExtSecurity = TRUE; return COMMAND_LINE_ERROR;
if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity, FALSE))
return COMMAND_LINE_ERROR;
if (!freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity, TRUE))
return COMMAND_LINE_ERROR;
} }
else else
{ {
@ -345,19 +362,27 @@ int shadow_server_parse_command_line(rdpShadowServer* server, int argc, char** a
} }
CommandLineSwitchCase(arg, "sec-rdp") CommandLineSwitchCase(arg, "sec-rdp")
{ {
settings->RdpSecurity = arg->Value ? TRUE : FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_RdpSecurity,
arg->Value ? TRUE : FALSE))
return COMMAND_LINE_ERROR;
} }
CommandLineSwitchCase(arg, "sec-tls") CommandLineSwitchCase(arg, "sec-tls")
{ {
settings->TlsSecurity = arg->Value ? TRUE : FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_TlsSecurity,
arg->Value ? TRUE : FALSE))
return COMMAND_LINE_ERROR;
} }
CommandLineSwitchCase(arg, "sec-nla") CommandLineSwitchCase(arg, "sec-nla")
{ {
settings->NlaSecurity = arg->Value ? TRUE : FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_NlaSecurity,
arg->Value ? TRUE : FALSE))
return COMMAND_LINE_ERROR;
} }
CommandLineSwitchCase(arg, "sec-ext") CommandLineSwitchCase(arg, "sec-ext")
{ {
settings->ExtSecurity = arg->Value ? TRUE : FALSE; if (!freerdp_settings_set_bool(settings, FreeRDP_ExtSecurity,
arg->Value ? TRUE : FALSE))
return COMMAND_LINE_ERROR;
} }
CommandLineSwitchCase(arg, "sam-file") CommandLineSwitchCase(arg, "sam-file")
{ {