FreeRDP
Loading...
Searching...
No Matches
TestClientStats.c
1
17
18#include <freerdp/config.h>
19
20#include <stdio.h>
21#include <string.h>
22
23#include <winpr/crt.h>
24#include <winpr/stream.h>
25#include <winpr/thread.h>
26
27#include <freerdp/addin.h>
28#include <freerdp/autodetect.h>
29#include <freerdp/client.h>
30#include <freerdp/client/channels.h>
31#include <freerdp/freerdp.h>
32
33#if defined(CHANNEL_RDPGFX_CLIENT)
34#include <freerdp/channels/rdpgfx.h>
35#include <freerdp/client/rdpgfx.h>
36#include <freerdp/codec/zgfx.h>
37#include <freerdp/dvc.h>
38#include <freerdp/gdi/gdi.h>
39#endif
40
41#if !defined(_WIN32)
42#include <arpa/inet.h>
43#include <netinet/in.h>
44#include <sys/socket.h>
45#include <sys/time.h>
46#include <unistd.h>
47#endif
48
49#define SESSION_STATS 8
50
51/* The default settings need rdpdr, which brings rdpsnd along: without it no connection starts.
52 * Emscripten has no plain TCP server sockets (setsockopt is not implemented, listen is a
53 * WebSocket server), so the loopback server cannot run there. */
54#if !defined(_WIN32) && !defined(__EMSCRIPTEN__) && defined(CHANNEL_RDPSND_CLIENT)
55#define TEST_NETWORK
56#endif
57
58#define TEST_CHECK(cond) \
59 do \
60 { \
61 if (!(cond)) \
62 { \
63 (void)fprintf(stderr, "%s:%d: failed: %s\n", __func__, __LINE__, #cond); \
64 return FALSE; \
65 } \
66 } while (0)
67
68static BOOL find_stat(const char* name, size_t* index)
69{
70 for (size_t x = 0; x < freerdp_client_stats_max_index(); x++)
71 {
72 if (strcmp(freerdp_client_stats_name_for_index(x), name) == 0)
73 {
74 *index = x;
75 return TRUE;
76 }
77 }
78 (void)fprintf(stderr, "no stat named %s\n", name);
79 return FALSE;
80}
81
82static uint64_t stat_value(const rdpContext* context, const char* name)
83{
84 size_t index = 0;
85 if (!find_stat(name, &index))
86 return UINT64_MAX;
87 return freerdp_client_stats_value_for_index(context, index);
88}
89
90static BOOL check_names(void)
91{
92 static const char* const session[SESSION_STATS] = {
93 "NETWORK_BYTES_RECEIVED", "NETWORK_BYTES_SENT", "NETWORK_PACKETS_RECEIVED",
94 "NETWORK_PACKETS_SENT", "NETWORK_BANDWIDTH_KBPS", "NETWORK_RTT_BASE_MS",
95 "NETWORK_RTT_AVERAGE_MS", "GFX_CAPS_VERSION"
96 };
97
98 const size_t max = freerdp_client_stats_max_index();
99#if defined(CHANNEL_RDPGFX_CLIENT)
100 TEST_CHECK(max == SESSION_STATS + rdpgfx_stats_max_index());
101#else
102 TEST_CHECK(max == SESSION_STATS);
103#endif
104
105 for (size_t x = 0; x < max; x++)
106 {
107 const char* name = freerdp_client_stats_name_for_index(x);
108 TEST_CHECK(name);
109 TEST_CHECK(strlen(name) > 0);
110 TEST_CHECK(strcmp(name, "FREERDP_CLIENT_STATS_UNUSED") != 0);
111 }
112 TEST_CHECK(strcmp(freerdp_client_stats_name_for_index(max), "FREERDP_CLIENT_STATS_UNUSED") ==
113 0);
114
115 /* each exactly once, in all the statistics */
116 for (size_t x = 0; x < ARRAYSIZE(session); x++)
117 {
118 size_t found = 0;
119 for (size_t y = 0; y < max; y++)
120 {
121 if (strcmp(freerdp_client_stats_name_for_index(y), session[x]) == 0)
122 found++;
123 }
124 TEST_CHECK(found == 1);
125 }
126 return TRUE;
127}
128
129static BOOL check_all_zero(const rdpContext* context)
130{
131 for (size_t x = 0; x <= freerdp_client_stats_max_index(); x++)
132 TEST_CHECK(freerdp_client_stats_value_for_index(context, x) == 0);
133 return TRUE;
134}
135
136static BOOL check_autodetect(rdpContext* context)
137{
138 /* a fresh session, nothing received or sent, no gdi and no graphics channel */
139 TEST_CHECK(!context->gdi);
140 TEST_CHECK(check_all_zero(context));
141
142 context->autodetect->netCharBandwidth = 1001;
143 context->autodetect->netCharBaseRTT = 1002;
144 context->autodetect->netCharAverageRTT = 1003;
145 TEST_CHECK(stat_value(context, "NETWORK_BANDWIDTH_KBPS") == 1001);
146 TEST_CHECK(stat_value(context, "NETWORK_RTT_BASE_MS") == 1002);
147 TEST_CHECK(stat_value(context, "NETWORK_RTT_AVERAGE_MS") == 1003);
148
149 context->autodetect->netCharBandwidth = 0;
150 context->autodetect->netCharBaseRTT = 0;
151 context->autodetect->netCharAverageRTT = 0;
152 TEST_CHECK(check_all_zero(context));
153
154 /* a context on its way down has neither */
155 context->autodetect->netCharBandwidth = 1001;
156 rdpAutoDetect* autodetect = context->autodetect;
157 rdpRdp* rdp = context->rdp;
158 context->autodetect = nullptr;
159 context->rdp = nullptr;
160 const BOOL rc = check_all_zero(context);
161 context->autodetect = autodetect;
162 context->rdp = rdp;
163 context->autodetect->netCharBandwidth = 0;
164 return rc;
165}
166
167#if defined(TEST_NETWORK)
168#define SERVER_BYTES 16
169
170typedef struct
171{
172 int listener;
173 int rc;
174} test_server;
175
176/* Takes the client's first packet and answers with something that is no RDP at all: enough for
177 * bytes to pass both ways through the real transport. */
178static DWORD WINAPI test_server_thread(LPVOID arg)
179{
180 test_server* server = (test_server*)arg;
181 BYTE buffer[256] = WINPR_C_ARRAY_INIT;
182
183 const int client = accept(server->listener, nullptr, nullptr);
184
185 /* the client tries again with the next protocol: refuse it, or it waits here for an answer */
186 (void)close(server->listener);
187 server->listener = -1;
188 if (client < 0)
189 return 1;
190
191 if (recv(client, buffer, sizeof(buffer), 0) > 0)
192 {
193 memset(buffer, 0xff, SERVER_BYTES);
194 if (send(client, buffer, SERVER_BYTES, 0) == SERVER_BYTES)
195 server->rc = 0;
196 }
197 (void)close(client);
198 return 0;
199}
200
201static BOOL check_network(rdpContext* context)
202{
203 BOOL rc = FALSE;
204 test_server server = { .listener = -1, .rc = -1 };
205 struct sockaddr_in addr = WINPR_C_ARRAY_INIT;
206 socklen_t len = sizeof(addr);
207 HANDLE thread = nullptr;
208
209 addr.sin_family = AF_INET;
210 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
211
212 /* accept() gives up as well, should the client never come */
213 const struct timeval timeout = { .tv_sec = 30, .tv_usec = 0 };
214
215 server.listener = socket(AF_INET, SOCK_STREAM, 0);
216 if ((server.listener < 0) ||
217 (setsockopt(server.listener, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) != 0) ||
218 (bind(server.listener, (struct sockaddr*)&addr, sizeof(addr)) != 0) ||
219 (listen(server.listener, 1) != 0) ||
220 (getsockname(server.listener, (struct sockaddr*)&addr, &len) != 0))
221 goto fail;
222
223 if (!freerdp_settings_set_string(context->settings, FreeRDP_ServerHostname, "127.0.0.1") ||
224 !freerdp_settings_set_uint32(context->settings, FreeRDP_ServerPort, ntohs(addr.sin_port)) ||
225 !freerdp_settings_set_string(context->settings, FreeRDP_Username, "stats") ||
226 !freerdp_settings_set_bool(context->settings, FreeRDP_AutoReconnectionEnabled, FALSE))
227 goto fail;
228
229 thread = CreateThread(nullptr, 0, test_server_thread, &server, 0, nullptr);
230 if (!thread)
231 goto fail;
232
233 /* fails: the other side is no RDP server, what passed until then is what counts */
234 (void)freerdp_connect(context->instance);
235 (void)WaitForSingleObject(thread, INFINITE);
236 (void)CloseHandle(thread);
237
238 if (server.rc != 0)
239 goto fail;
240 /* the server sent 16 bytes, the client's connection request is longer than that */
241 {
242 const uint64_t received = stat_value(context, "NETWORK_BYTES_RECEIVED");
243 const uint64_t sent = stat_value(context, "NETWORK_BYTES_SENT");
244 (void)printf("network: received %" PRIu64 ", sent %" PRIu64 "\n", received, sent);
245 TEST_CHECK((received > 0) && (received <= SERVER_BYTES));
246 TEST_CHECK(sent > SERVER_BYTES);
247 }
248 rc = TRUE;
249fail:
250 if (server.listener >= 0)
251 (void)close(server.listener);
252 if (!rc)
253 (void)fprintf(stderr, "[%s] failed\n", __func__);
254 return rc;
255}
256#endif
257
258#if defined(CHANNEL_RDPGFX_CLIENT)
259typedef struct
260{
261 IDRDYNVC_ENTRY_POINTS iface;
262 rdpContext* context;
263 IWTSPlugin* plugin;
264} test_entry_points;
265
266typedef struct
267{
268 IWTSVirtualChannelManager iface;
269 IWTSListener listener;
270 IWTSListenerCallback* listenerCallback;
271} test_channel_manager;
272
273static UINT test_register_plugin(IDRDYNVC_ENTRY_POINTS* pEntryPoints,
274 WINPR_ATTR_UNUSED const char* name, IWTSPlugin* pPlugin)
275{
276 ((test_entry_points*)pEntryPoints)->plugin = pPlugin;
277 return CHANNEL_RC_OK;
278}
279
280static IWTSPlugin* test_get_plugin(WINPR_ATTR_UNUSED IDRDYNVC_ENTRY_POINTS* pEntryPoints,
281 WINPR_ATTR_UNUSED const char* name)
282{
283 return nullptr;
284}
285
286static const ADDIN_ARGV* test_get_plugin_data(WINPR_ATTR_UNUSED IDRDYNVC_ENTRY_POINTS* pEntryPoints)
287{
288 return nullptr;
289}
290
291static rdpSettings* test_get_rdp_settings(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
292{
293 return ((test_entry_points*)pEntryPoints)->context->settings;
294}
295
296static rdpContext* test_get_rdp_context(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
297{
298 return ((test_entry_points*)pEntryPoints)->context;
299}
300
301static UINT test_create_listener(IWTSVirtualChannelManager* pChannelMgr,
302 WINPR_ATTR_UNUSED const char* pszChannelName,
303 WINPR_ATTR_UNUSED ULONG ulFlags,
304 IWTSListenerCallback* pListenerCallback, IWTSListener** ppListener)
305{
306 test_channel_manager* mgr = (test_channel_manager*)pChannelMgr;
307 mgr->listenerCallback = pListenerCallback;
308 if (ppListener)
309 *ppListener = &mgr->listener;
310 return CHANNEL_RC_OK;
311}
312
313static UINT test_destroy_listener(IWTSVirtualChannelManager* pChannelMgr,
314 WINPR_ATTR_UNUSED IWTSListener* pListener)
315{
316 ((test_channel_manager*)pChannelMgr)->listenerCallback = nullptr;
317 return CHANNEL_RC_OK;
318}
319
320static UINT32 test_get_channel_id(WINPR_ATTR_UNUSED IWTSVirtualChannel* channel)
321{
322 return 1;
323}
324
325static const char* test_get_channel_name(WINPR_ATTR_UNUSED IWTSVirtualChannel* channel)
326{
327 return RDPGFX_DVC_CHANNEL_NAME;
328}
329
330static IWTSVirtualChannel* test_find_channel_by_id(WINPR_ATTR_UNUSED IWTSVirtualChannelManager* mgr,
331 WINPR_ATTR_UNUSED UINT32 ChannelId)
332{
333 return nullptr;
334}
335
336static UINT test_channel_write(WINPR_ATTR_UNUSED IWTSVirtualChannel* pChannel,
337 WINPR_ATTR_UNUSED ULONG cbSize,
338 WINPR_ATTR_UNUSED const BYTE* pBuffer,
339 WINPR_ATTR_UNUSED void* pReserved)
340{
341 return CHANNEL_RC_OK;
342}
343
344static UINT test_channel_close(WINPR_ATTR_UNUSED IWTSVirtualChannel* pChannel)
345{
346 return CHANNEL_RC_OK;
347}
348
349static UINT send_start_frame(IWTSVirtualChannelCallback* callback)
350{
351 wStream* s = Stream_New(nullptr, 2 + RDPGFX_HEADER_SIZE + RDPGFX_START_FRAME_PDU_SIZE);
352 if (!s)
353 return CHANNEL_RC_NO_MEMORY;
354 Stream_Write_UINT8(s, ZGFX_SEGMENTED_SINGLE);
355 Stream_Write_UINT8(s, ZGFX_PACKET_COMPR_TYPE_RDP8);
356 Stream_Write_UINT16(s, RDPGFX_CMDID_STARTFRAME);
357 Stream_Write_UINT16(s, 0); /* flags */
358 Stream_Write_UINT32(s, RDPGFX_HEADER_SIZE + RDPGFX_START_FRAME_PDU_SIZE);
359 Stream_Write_UINT32(s, 0); /* timestamp */
360 Stream_Write_UINT32(s, 1); /* frameId */
361 Stream_SealLength(s);
362 Stream_ResetPosition(s);
363 const UINT rc = callback->OnDataReceived(callback, s);
364 Stream_Free(s, TRUE);
365 return rc;
366}
367
368/* a graphics channel, reached the way a session reaches it: context->gdi->gfx */
369static BOOL check_gfx_channel(rdpContext* context, IWTSPlugin* plugin, test_channel_manager* mgr)
370{
371 IWTSVirtualChannel channel = WINPR_C_ARRAY_INIT;
372 channel.Write = test_channel_write;
373 channel.Close = test_channel_close;
374
375 TEST_CHECK(plugin->Initialize(plugin, &mgr->iface) == CHANNEL_RC_OK);
376 TEST_CHECK(mgr->listenerCallback);
377
378 IWTSVirtualChannelCallback* callback = nullptr;
379 BOOL accept = TRUE;
380 TEST_CHECK(mgr->listenerCallback->OnNewChannelConnection(
381 mgr->listenerCallback, &channel, nullptr, &accept, &callback) == CHANNEL_RC_OK);
382 TEST_CHECK(callback);
383 TEST_CHECK(callback->OnOpen(callback) == CHANNEL_RC_OK);
384
385 rdpGdi gdi = WINPR_C_ARRAY_INIT;
386 context->gdi = &gdi;
387
388 /* no gfx yet, as on a session whose graphics channel closed */
389 RdpgfxClientContext* gfx = (RdpgfxClientContext*)plugin->pInterface;
390 gfx->ConfirmedCaps.version = RDPGFX_CAPVERSION_107;
391 BOOL rc = (stat_value(context, "RDPGFX_CMDID_STARTFRAME") == 0) &&
392 (stat_value(context, "GFX_CAPS_VERSION") == 0);
393
394 if (rc)
395 {
396 gdi.gfx = gfx;
397 rc = (stat_value(context, "GFX_CAPS_VERSION") == RDPGFX_CAPVERSION_107) &&
398 (stat_value(context, "RDPGFX_CMDID_STARTFRAME") == 0) &&
399 (send_start_frame(callback) == CHANNEL_RC_OK) &&
400 (stat_value(context, "RDPGFX_CMDID_STARTFRAME") == 1) &&
401 (stat_value(context, "RDPGFX_CMDID_ENDFRAME") == 0);
402 gdi.gfx = nullptr;
403 rc = rc && (stat_value(context, "RDPGFX_CMDID_STARTFRAME") == 0) &&
404 (stat_value(context, "GFX_CAPS_VERSION") == 0);
405 }
406
407 context->gdi = nullptr;
408 (void)callback->OnClose(callback);
409 TEST_CHECK(rc);
410 return TRUE;
411}
412
413static BOOL check_gfx(rdpContext* context)
414{
415 PDVC_PLUGIN_ENTRY pluginEntry = WINPR_FUNC_PTR_CAST(
416 freerdp_channels_load_static_addin_entry(RDPGFX_CHANNEL_NAME, nullptr, nullptr,
417 FREERDP_ADDIN_CHANNEL_DYNAMIC),
418 PDVC_PLUGIN_ENTRY);
419 TEST_CHECK(pluginEntry);
420
421 test_entry_points ep = WINPR_C_ARRAY_INIT;
422 ep.iface.RegisterPlugin = test_register_plugin;
423 ep.iface.GetPlugin = test_get_plugin;
424 ep.iface.GetPluginData = test_get_plugin_data;
425 ep.iface.GetRdpSettings = test_get_rdp_settings;
426 ep.iface.GetRdpContext = test_get_rdp_context;
427 ep.context = context;
428
429 TEST_CHECK(pluginEntry(&ep.iface) == CHANNEL_RC_OK);
430 TEST_CHECK(ep.plugin);
431
432 test_channel_manager mgr = WINPR_C_ARRAY_INIT;
433 mgr.iface.CreateListener = test_create_listener;
434 mgr.iface.DestroyListener = test_destroy_listener;
435 mgr.iface.GetChannelId = test_get_channel_id;
436 mgr.iface.GetChannelName = test_get_channel_name;
437 mgr.iface.FindChannelById = test_find_channel_by_id;
438
439 const BOOL rc = check_gfx_channel(context, ep.plugin, &mgr);
440
441 /* frees the plugin */
442 (void)ep.plugin->Terminated(ep.plugin);
443 return rc;
444}
445#endif
446
447static rdpContext* new_context(void)
448{
449 RDP_CLIENT_ENTRY_POINTS entry = WINPR_C_ARRAY_INIT;
450 entry.Version = RDP_CLIENT_INTERFACE_VERSION;
451 entry.Size = sizeof(RDP_CLIENT_ENTRY_POINTS_V1);
452 entry.ContextSize = sizeof(rdpClientContext);
453 return freerdp_client_context_new(&entry);
454}
455
456int TestClientStats(WINPR_ATTR_UNUSED int argc, WINPR_ATTR_UNUSED char* argv[])
457{
458 if (!check_names())
459 return -1;
460 if (!check_all_zero(nullptr))
461 return -1;
462
463 rdpContext* context = new_context();
464 if (!context)
465 return -1;
466
467 BOOL rc = check_autodetect(context);
468#if defined(CHANNEL_RDPGFX_CLIENT)
469 rc = rc && check_gfx(context);
470#endif
471#if defined(TEST_NETWORK)
472 rc = rc && check_network(context);
473#endif
474
475 freerdp_client_context_free(context);
476 return rc ? 0 : -1;
477}
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_bool(rdpSettings *settings, FreeRDP_Settings_Keys_Bool id, BOOL val)
Sets a BOOL settings value.
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 val)
Sets a UINT32 settings value.
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_string(rdpSettings *settings, FreeRDP_Settings_Keys_String id, const char *val)
Sets a string settings value. The param is copied.