Coverage Report

Created: 2025-08-29 06:49

/src/FreeRDP/libfreerdp/core/autodetect.c
Line
Count
Source (jump to first uncovered line)
1
/**
2
 * FreeRDP: A Remote Desktop Protocol Implementation
3
 * Auto-Detect PDUs
4
 *
5
 * Copyright 2014 Dell Software <Mike.McDonald@software.dell.com>
6
 *
7
 * Licensed under the Apache License, Version 2.0 (the "License");
8
 * you may not use this file except in compliance with the License.
9
 * You may obtain a copy of the License at
10
 *
11
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 *
13
 * Unless required by applicable law or agreed to in writing, software
14
 * distributed under the License is distributed on an "AS IS" BASIS,
15
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
 * See the License for the specific language governing permissions and
17
 * limitations under the License.
18
 */
19
20
#include <freerdp/config.h>
21
22
#include <winpr/crypto.h>
23
#include <winpr/assert.h>
24
25
#include "autodetect.h"
26
27
6.15k
#define TYPE_ID_AUTODETECT_REQUEST 0x00
28
4.11k
#define TYPE_ID_AUTODETECT_RESPONSE 0x01
29
30
55
#define RDP_RTT_REQUEST_TYPE_CONTINUOUS 0x0001
31
31
#define RDP_RTT_REQUEST_TYPE_CONNECTTIME 0x1001
32
33
1.17k
#define RDP_RTT_RESPONSE_TYPE 0x0000
34
35
34
#define RDP_BW_START_REQUEST_TYPE_CONTINUOUS 0x0014
36
22
#define RDP_BW_START_REQUEST_TYPE_TUNNEL 0x0114
37
21
#define RDP_BW_START_REQUEST_TYPE_CONNECTTIME 0x1014
38
84
#define RDP_BW_PAYLOAD_REQUEST_TYPE 0x0002
39
440
#define RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME 0x002B
40
294
#define RDP_BW_STOP_REQUEST_TYPE_CONTINUOUS 0x0429
41
162
#define RDP_BW_STOP_REQUEST_TYPE_TUNNEL 0x0629
42
43
16
#define RDP_NETCHAR_SYNC_RESPONSE_TYPE 0x0018
44
45
43
#define RDP_NETCHAR_RESULTS_0x0840 0x0840U
46
58
#define RDP_NETCHAR_RESULTS_0x0880 0x0880U
47
97
#define RDP_NETCHAR_RESULTS_0x08C0 0x08C0U
48
49
typedef struct
50
{
51
  UINT8 headerLength;
52
  UINT8 headerTypeId;
53
  UINT16 sequenceNumber;
54
  UINT16 requestType;
55
} AUTODETECT_REQ_PDU;
56
57
typedef struct
58
{
59
  UINT8 headerLength;
60
  UINT8 headerTypeId;
61
  UINT16 sequenceNumber;
62
  UINT16 responseType;
63
} AUTODETECT_RSP_PDU;
64
65
static const char* autodetect_header_type_string(UINT8 headerType, char* buffer, size_t size)
66
6.28k
{
67
6.28k
  const char* str = NULL;
68
6.28k
  switch (headerType)
69
6.28k
  {
70
1.65k
    case TYPE_ID_AUTODETECT_REQUEST:
71
1.65k
      str = "TYPE_ID_AUTODETECT_REQUEST";
72
1.65k
      break;
73
124
    case TYPE_ID_AUTODETECT_RESPONSE:
74
124
      str = "TYPE_ID_AUTODETECT_RESPONSE";
75
124
      break;
76
4.50k
    default:
77
4.50k
      str = "TYPE_ID_AUTODETECT_UNKNOWN";
78
4.50k
      break;
79
6.28k
  }
80
81
6.28k
  (void)_snprintf(buffer, size, "%s [0x%08" PRIx8 "]", str, headerType);
82
6.28k
  return buffer;
83
6.28k
}
84
85
static const char* autodetect_request_type_to_string(UINT32 requestType)
86
6.28k
{
87
6.28k
  switch (requestType)
88
6.28k
  {
89
1.13k
    case RDP_RTT_RESPONSE_TYPE:
90
1.13k
      return "RDP_RTT_RESPONSE_TYPE";
91
28
    case RDP_BW_RESULTS_RESPONSE_TYPE_CONNECTTIME:
92
28
      return "RDP_BW_RESULTS_RESPONSE_TYPE_CONNECTTIME";
93
14
    case RDP_BW_RESULTS_RESPONSE_TYPE_CONTINUOUS:
94
14
      return "RDP_BW_RESULTS_RESPONSE_TYPE_CONTINUOUS";
95
33
    case RDP_RTT_REQUEST_TYPE_CONTINUOUS:
96
33
      return "RDP_RTT_REQUEST_TYPE_CONTINUOUS";
97
6
    case RDP_RTT_REQUEST_TYPE_CONNECTTIME:
98
6
      return "RDP_RTT_REQUEST_TYPE_CONNECTTIME";
99
21
    case RDP_BW_START_REQUEST_TYPE_CONTINUOUS:
100
21
      return "RDP_BW_START_REQUEST_TYPE_CONTINUOUS";
101
11
    case RDP_BW_START_REQUEST_TYPE_TUNNEL:
102
11
      return "RDP_BW_START_REQUEST_TYPE_TUNNEL";
103
7
    case RDP_BW_START_REQUEST_TYPE_CONNECTTIME:
104
7
      return "RDP_BW_START_REQUEST_TYPE_CONNECTTIME";
105
21
    case RDP_BW_PAYLOAD_REQUEST_TYPE:
106
21
      return "RDP_BW_PAYLOAD_REQUEST_TYPE";
107
6
    case RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME:
108
6
      return "RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME";
109
6
    case RDP_BW_STOP_REQUEST_TYPE_CONTINUOUS:
110
6
      return "RDP_BW_STOP_REQUEST_TYPE_CONTINUOUS";
111
4
    case RDP_BW_STOP_REQUEST_TYPE_TUNNEL:
112
4
      return "RDP_BW_STOP_REQUEST_TYPE_TUNNEL";
113
7
    case RDP_NETCHAR_RESULTS_0x0840:
114
7
      return "RDP_NETCHAR_RESULTS_0x0840";
115
6
    case RDP_NETCHAR_RESULTS_0x0880:
116
6
      return "RDP_NETCHAR_RESULTS_0x0880";
117
10
    case RDP_NETCHAR_RESULTS_0x08C0:
118
10
      return "RDP_NETCHAR_RESULTS_0x08C0";
119
4.96k
    default:
120
4.96k
      return "UNKNOWN";
121
6.28k
  }
122
6.28k
}
123
124
static const char* autodetect_request_type_to_string_buffer(UINT32 requestType, char* buffer,
125
                                                            size_t size)
126
6.28k
{
127
6.28k
  const char* str = autodetect_request_type_to_string(requestType);
128
6.28k
  (void)_snprintf(buffer, size, "%s [0x%08" PRIx32 "]", str, requestType);
129
6.28k
  return buffer;
130
6.28k
}
131
132
static BOOL autodetect_send_rtt_measure_request(rdpAutoDetect* autodetect,
133
                                                WINPR_ATTR_UNUSED RDP_TRANSPORT_TYPE transport,
134
                                                UINT16 sequenceNumber)
135
0
{
136
0
  UINT16 requestType = 0;
137
0
  UINT16 sec_flags = 0;
138
0
  wStream* s = NULL;
139
140
0
  WINPR_ASSERT(autodetect);
141
0
  WINPR_ASSERT(autodetect->context);
142
143
0
  s = rdp_message_channel_pdu_init(autodetect->context->rdp, &sec_flags);
144
0
  if (!s)
145
0
    return FALSE;
146
147
0
  if (freerdp_get_state(autodetect->context) < CONNECTION_STATE_ACTIVE)
148
0
    requestType = RDP_RTT_REQUEST_TYPE_CONNECTTIME;
149
0
  else
150
0
    requestType = RDP_RTT_REQUEST_TYPE_CONTINUOUS;
151
152
0
  WLog_Print(autodetect->log, WLOG_TRACE, "sending RTT Measure Request PDU");
153
0
  Stream_Write_UINT8(s, 0x06);                       /* headerLength (1 byte) */
154
0
  Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* headerTypeId (1 byte) */
155
0
  Stream_Write_UINT16(s, sequenceNumber);            /* sequenceNumber (2 bytes) */
156
0
  Stream_Write_UINT16(s, requestType);               /* requestType (2 bytes) */
157
0
  autodetect->rttMeasureStartTime = GetTickCount64();
158
0
  return rdp_send_message_channel_pdu(autodetect->context->rdp, s,
159
0
                                      sec_flags | SEC_AUTODETECT_REQ);
160
0
}
161
162
static BOOL autodetect_send_rtt_measure_response(rdpAutoDetect* autodetect, UINT16 sequenceNumber)
163
3
{
164
3
  UINT16 sec_flags = 0;
165
3
  wStream* s = NULL;
166
167
3
  WINPR_ASSERT(autodetect);
168
3
  WINPR_ASSERT(autodetect->context);
169
170
  /* Send the response PDU to the server */
171
3
  s = rdp_message_channel_pdu_init(autodetect->context->rdp, &sec_flags);
172
173
3
  if (!s)
174
0
    return FALSE;
175
176
3
  WLog_Print(autodetect->log, WLOG_TRACE,
177
3
             "sending RTT Measure Response PDU (seqNumber=0x%" PRIx16 ")", sequenceNumber);
178
3
  Stream_Write_UINT8(s, 0x06);                        /* headerLength (1 byte) */
179
3
  Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_RESPONSE); /* headerTypeId (1 byte) */
180
3
  Stream_Write_UINT16(s, sequenceNumber);             /* sequenceNumber (2 bytes) */
181
3
  Stream_Write_UINT16(s, RDP_RTT_RESPONSE_TYPE);      /* responseType (1 byte) */
182
3
  return rdp_send_message_channel_pdu(autodetect->context->rdp, s,
183
3
                                      sec_flags | SEC_AUTODETECT_RSP);
184
3
}
185
186
static BOOL autodetect_send_bandwidth_measure_start(rdpAutoDetect* autodetect,
187
                                                    WINPR_ATTR_UNUSED RDP_TRANSPORT_TYPE transport,
188
                                                    UINT16 sequenceNumber)
189
0
{
190
0
  UINT16 requestType = 0;
191
0
  UINT16 sec_flags = 0;
192
0
  wStream* s = NULL;
193
194
0
  WINPR_ASSERT(autodetect);
195
0
  WINPR_ASSERT(autodetect->context);
196
197
0
  s = rdp_message_channel_pdu_init(autodetect->context->rdp, &sec_flags);
198
0
  if (!s)
199
0
    return FALSE;
200
201
0
  if (freerdp_get_state(autodetect->context) < CONNECTION_STATE_ACTIVE)
202
0
    requestType = RDP_BW_START_REQUEST_TYPE_CONNECTTIME;
203
0
  else
204
0
    requestType = RDP_BW_START_REQUEST_TYPE_CONTINUOUS;
205
206
0
  WLog_Print(autodetect->log, WLOG_TRACE,
207
0
             "sending Bandwidth Measure Start PDU(seqNumber=%" PRIu16 ")", sequenceNumber);
208
0
  Stream_Write_UINT8(s, 0x06);                       /* headerLength (1 byte) */
209
0
  Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* headerTypeId (1 byte) */
210
0
  Stream_Write_UINT16(s, sequenceNumber);            /* sequenceNumber (2 bytes) */
211
0
  Stream_Write_UINT16(s, requestType);               /* requestType (2 bytes) */
212
0
  return rdp_send_message_channel_pdu(autodetect->context->rdp, s,
213
0
                                      sec_flags | SEC_AUTODETECT_REQ);
214
0
}
215
216
static BOOL
217
autodetect_send_bandwidth_measure_payload(rdpAutoDetect* autodetect,
218
                                          WINPR_ATTR_UNUSED RDP_TRANSPORT_TYPE transport,
219
                                          UINT16 sequenceNumber, UINT16 payloadLength)
220
0
{
221
0
  UINT16 sec_flags = 0;
222
0
  wStream* s = NULL;
223
224
0
  WINPR_ASSERT(autodetect);
225
0
  WINPR_ASSERT(autodetect->context);
226
227
0
  WINPR_ASSERT(freerdp_get_state(autodetect->context) < CONNECTION_STATE_ACTIVE);
228
229
0
  s = rdp_message_channel_pdu_init(autodetect->context->rdp, &sec_flags);
230
0
  if (!s)
231
0
    return FALSE;
232
233
0
  WLog_Print(autodetect->log, WLOG_TRACE,
234
0
             "sending Bandwidth Measure Payload PDU -> payloadLength=%" PRIu16 "", payloadLength);
235
  /* 4-bytes aligned */
236
0
  payloadLength &= ~3;
237
238
0
  if (!Stream_EnsureRemainingCapacity(s, 8 + payloadLength))
239
0
  {
240
0
    WLog_Print(autodetect->log, WLOG_ERROR, "Failed to ensure %lu bytes in stream",
241
0
               8ul + payloadLength);
242
0
    Stream_Release(s);
243
0
    return FALSE;
244
0
  }
245
246
0
  Stream_Write_UINT8(s, 0x08);                         /* headerLength (1 byte) */
247
0
  Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST);   /* headerTypeId (1 byte) */
248
0
  Stream_Write_UINT16(s, sequenceNumber);              /* sequenceNumber (2 bytes) */
249
0
  Stream_Write_UINT16(s, RDP_BW_PAYLOAD_REQUEST_TYPE); /* requestType (2 bytes) */
250
0
  Stream_Write_UINT16(s, payloadLength);               /* payloadLength (2 bytes) */
251
  /* Random data (better measurement in case the line is compressed) */
252
0
  winpr_RAND(Stream_Pointer(s), payloadLength);
253
0
  Stream_Seek(s, payloadLength);
254
0
  return rdp_send_message_channel_pdu(autodetect->context->rdp, s,
255
0
                                      sec_flags | SEC_AUTODETECT_REQ);
256
0
}
257
258
static BOOL autodetect_send_bandwidth_measure_stop(rdpAutoDetect* autodetect,
259
                                                   WINPR_ATTR_UNUSED RDP_TRANSPORT_TYPE transport,
260
                                                   UINT16 sequenceNumber, UINT16 payloadLength)
261
0
{
262
0
  UINT16 requestType = 0;
263
0
  UINT16 sec_flags = 0;
264
0
  wStream* s = NULL;
265
266
0
  WINPR_ASSERT(autodetect);
267
0
  WINPR_ASSERT(autodetect->context);
268
269
0
  s = rdp_message_channel_pdu_init(autodetect->context->rdp, &sec_flags);
270
0
  if (!s)
271
0
    return FALSE;
272
273
0
  if (freerdp_get_state(autodetect->context) < CONNECTION_STATE_ACTIVE)
274
0
    requestType = RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME;
275
0
  else
276
0
    requestType = RDP_BW_STOP_REQUEST_TYPE_CONTINUOUS;
277
278
0
  if (requestType == RDP_BW_STOP_REQUEST_TYPE_CONTINUOUS)
279
0
    payloadLength = 0;
280
281
0
  WLog_Print(autodetect->log, WLOG_TRACE,
282
0
             "sending Bandwidth Measure Stop PDU -> payloadLength=%" PRIu16 "", payloadLength);
283
  /* 4-bytes aligned */
284
0
  payloadLength &= ~3;
285
0
  Stream_Write_UINT8(s, requestType == RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME
286
0
                            ? 0x08
287
0
                            : 0x06);                 /* headerLength (1 byte) */
288
0
  Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* headerTypeId (1 byte) */
289
0
  Stream_Write_UINT16(s, sequenceNumber);            /* sequenceNumber (2 bytes) */
290
0
  Stream_Write_UINT16(s, requestType);               /* requestType (2 bytes) */
291
292
0
  if (requestType == RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME)
293
0
  {
294
0
    Stream_Write_UINT16(s, payloadLength); /* payloadLength (2 bytes) */
295
296
0
    if (payloadLength > 0)
297
0
    {
298
0
      if (!Stream_EnsureRemainingCapacity(s, payloadLength))
299
0
      {
300
0
        WLog_Print(autodetect->log, WLOG_ERROR,
301
0
                   "Failed to ensure %" PRIu16 " bytes in stream", payloadLength);
302
0
        Stream_Release(s);
303
0
        return FALSE;
304
0
      }
305
306
      /* Random data (better measurement in case the line is compressed) */
307
0
      winpr_RAND(Stream_Pointer(s), payloadLength);
308
0
      Stream_Seek(s, payloadLength);
309
0
    }
310
0
  }
311
312
0
  return rdp_send_message_channel_pdu(autodetect->context->rdp, s,
313
0
                                      sec_flags | SEC_AUTODETECT_REQ);
314
0
}
315
316
static BOOL autodetect_send_bandwidth_measure_results(rdpAutoDetect* autodetect,
317
                                                      RDP_TRANSPORT_TYPE transport,
318
                                                      UINT16 responseType, UINT16 sequenceNumber)
319
138
{
320
138
  BOOL success = TRUE;
321
138
  UINT16 sec_flags = 0;
322
138
  UINT64 timeDelta = GetTickCount64();
323
324
138
  WINPR_ASSERT(autodetect);
325
138
  WINPR_ASSERT(autodetect->context);
326
327
  /* Compute the total time */
328
138
  if (autodetect->bandwidthMeasureStartTime > timeDelta)
329
0
  {
330
0
    WLog_Print(autodetect->log, WLOG_WARN,
331
0
               "Invalid bandwidthMeasureStartTime %" PRIu64 " > current %" PRIu64
332
0
               ", trimming to 0",
333
0
               autodetect->bandwidthMeasureStartTime, timeDelta);
334
0
    timeDelta = 0;
335
0
  }
336
138
  else
337
138
    timeDelta -= autodetect->bandwidthMeasureStartTime;
338
339
  /* Send the result PDU to the server */
340
138
  wStream* s = rdp_message_channel_pdu_init(autodetect->context->rdp, &sec_flags);
341
342
138
  if (!s)
343
0
    return FALSE;
344
345
138
  WLog_Print(autodetect->log, WLOG_TRACE,
346
138
             "sending Bandwidth Measure Results PDU -> timeDelta=%" PRIu64 ", byteCount=%" PRIu32
347
138
             "",
348
138
             timeDelta, autodetect->bandwidthMeasureByteCount);
349
350
138
  Stream_Write_UINT8(s, 0x0E);                                   /* headerLength (1 byte) */
351
138
  Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_RESPONSE);            /* headerTypeId (1 byte) */
352
138
  Stream_Write_UINT16(s, sequenceNumber);                        /* sequenceNumber (2 bytes) */
353
138
  Stream_Write_UINT16(s, responseType);                          /* responseType (1 byte) */
354
138
  Stream_Write_UINT32(s, (UINT32)MIN(timeDelta, UINT32_MAX));    /* timeDelta (4 bytes) */
355
138
  Stream_Write_UINT32(s, autodetect->bandwidthMeasureByteCount); /* byteCount (4 bytes) */
356
138
  IFCALLRET(autodetect->ClientBandwidthMeasureResult, success, autodetect, transport,
357
138
            responseType, sequenceNumber, (UINT32)MIN(timeDelta, UINT32_MAX),
358
138
            autodetect->bandwidthMeasureByteCount);
359
360
138
  if (!success)
361
0
  {
362
0
    WLog_Print(autodetect->log, WLOG_ERROR, "ClientBandwidthMeasureResult failed");
363
0
    Stream_Release(s);
364
0
    return FALSE;
365
0
  }
366
367
138
  return rdp_send_message_channel_pdu(autodetect->context->rdp, s,
368
138
                                      sec_flags | SEC_AUTODETECT_RSP);
369
138
}
370
371
static BOOL autodetect_send_netchar_result(rdpAutoDetect* autodetect,
372
                                           WINPR_ATTR_UNUSED RDP_TRANSPORT_TYPE transport,
373
                                           UINT16 sequenceNumber,
374
                                           const rdpNetworkCharacteristicsResult* result)
375
28
{
376
28
  UINT16 sec_flags = 0;
377
28
  wStream* s = NULL;
378
379
28
  WINPR_ASSERT(autodetect);
380
28
  WINPR_ASSERT(autodetect->context);
381
382
28
  s = rdp_message_channel_pdu_init(autodetect->context->rdp, &sec_flags);
383
384
28
  if (!s)
385
0
    return FALSE;
386
387
28
  WLog_Print(autodetect->log, WLOG_TRACE, "sending Network Characteristics Result PDU");
388
389
28
  switch (result->type)
390
28
  {
391
8
    case RDP_NETCHAR_RESULT_TYPE_BASE_RTT_AVG_RTT:
392
8
      Stream_Write_UINT8(s, 0x0E);                       /* headerLength (1 byte) */
393
8
      Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* headerTypeId (1 byte) */
394
8
      Stream_Write_UINT16(s, sequenceNumber);            /* sequenceNumber (2 bytes) */
395
8
      WINPR_ASSERT((result->type <= UINT16_MAX));
396
8
      WINPR_ASSERT((result->type >= 0));
397
8
      Stream_Write_UINT16(s, (UINT16)result->type);      /* requestType (2 bytes) */
398
8
      Stream_Write_UINT32(s, result->baseRTT);           /* baseRTT (4 bytes) */
399
8
      Stream_Write_UINT32(s, result->averageRTT);        /* averageRTT (4 bytes) */
400
8
      break;
401
8
    case RDP_NETCHAR_RESULT_TYPE_BW_AVG_RTT:
402
2
      Stream_Write_UINT8(s, 0x0E);                       /* headerLength (1 byte) */
403
2
      Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* headerTypeId (1 byte) */
404
2
      Stream_Write_UINT16(s, sequenceNumber);            /* sequenceNumber (2 bytes) */
405
2
      WINPR_ASSERT((result->type <= UINT16_MAX));
406
2
      WINPR_ASSERT((result->type >= 0));
407
2
      Stream_Write_UINT16(s, (UINT16)result->type);      /* requestType (2 bytes) */
408
2
      Stream_Write_UINT32(s, result->bandwidth);         /* bandwidth (4 bytes) */
409
2
      Stream_Write_UINT32(s, result->averageRTT);        /* averageRTT (4 bytes) */
410
2
      break;
411
18
    case RDP_NETCHAR_RESULT_TYPE_BASE_RTT_BW_AVG_RTT:
412
18
      Stream_Write_UINT8(s, 0x12);                       /* headerLength (1 byte) */
413
18
      Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* headerTypeId (1 byte) */
414
18
      Stream_Write_UINT16(s, sequenceNumber);            /* sequenceNumber (2 bytes) */
415
18
      WINPR_ASSERT((result->type <= UINT16_MAX));
416
18
      WINPR_ASSERT((result->type >= 0));
417
18
      Stream_Write_UINT16(s, (UINT16)result->type);      /* requestType (2 bytes) */
418
18
      Stream_Write_UINT32(s, result->baseRTT);           /* baseRTT (4 bytes) */
419
18
      Stream_Write_UINT32(s, result->bandwidth);         /* bandwidth (4 bytes) */
420
18
      Stream_Write_UINT32(s, result->averageRTT);        /* averageRTT (4 bytes) */
421
18
      break;
422
18
    default:
423
0
      WINPR_ASSERT(FALSE);
424
0
      break;
425
28
  }
426
427
28
  return rdp_send_message_channel_pdu(autodetect->context->rdp, s,
428
28
                                      sec_flags | SEC_AUTODETECT_REQ);
429
28
}
430
431
static FREERDP_AUTODETECT_STATE
432
autodetect_on_connect_time_auto_detect_begin_default(rdpAutoDetect* autodetect)
433
0
{
434
0
  WINPR_ASSERT(autodetect);
435
0
  WINPR_ASSERT(autodetect->RTTMeasureRequest);
436
437
0
  if (!autodetect->RTTMeasureRequest(autodetect, RDP_TRANSPORT_TCP, 0x23))
438
0
    return FREERDP_AUTODETECT_STATE_FAIL;
439
440
0
  return FREERDP_AUTODETECT_STATE_REQUEST;
441
0
}
442
443
static FREERDP_AUTODETECT_STATE
444
autodetect_on_connect_time_auto_detect_progress_default(rdpAutoDetect* autodetect)
445
0
{
446
0
  WINPR_ASSERT(autodetect);
447
448
0
  if (autodetect->state == FREERDP_AUTODETECT_STATE_RESPONSE ||
449
0
      autodetect->state == FREERDP_AUTODETECT_STATE_COMPLETE)
450
0
    return FREERDP_AUTODETECT_STATE_COMPLETE;
451
452
0
  return autodetect->state;
453
0
}
454
455
static BOOL autodetect_recv_rtt_measure_request(rdpAutoDetect* autodetect,
456
                                                WINPR_ATTR_UNUSED RDP_TRANSPORT_TYPE transport,
457
                                                WINPR_ATTR_UNUSED wStream* s,
458
                                                const AUTODETECT_REQ_PDU* autodetectReqPdu)
459
25
{
460
25
  WINPR_ASSERT(autodetect);
461
25
  WINPR_ASSERT(s);
462
25
  WINPR_ASSERT(autodetectReqPdu);
463
464
25
  if (autodetectReqPdu->headerLength != 0x06)
465
22
  {
466
22
    WLog_Print(autodetect->log, WLOG_ERROR,
467
22
               "autodetectReqPdu->headerLength != 0x06 [0x%02" PRIx8 "]",
468
22
               autodetectReqPdu->headerLength);
469
22
    return FALSE;
470
22
  }
471
472
3
  WLog_Print(autodetect->log, WLOG_TRACE, "received RTT Measure Request PDU");
473
  /* Send a response to the server */
474
3
  return autodetect_send_rtt_measure_response(autodetect, autodetectReqPdu->sequenceNumber);
475
25
}
476
477
static BOOL autodetect_recv_rtt_measure_response(rdpAutoDetect* autodetect,
478
                                                 RDP_TRANSPORT_TYPE transport,
479
                                                 WINPR_ATTR_UNUSED wStream* s,
480
                                                 const AUTODETECT_RSP_PDU* autodetectRspPdu)
481
32
{
482
32
  BOOL success = TRUE;
483
484
32
  WINPR_ASSERT(autodetect);
485
32
  WINPR_ASSERT(autodetectRspPdu);
486
487
32
  if (autodetectRspPdu->headerLength != 0x06)
488
12
  {
489
12
    WLog_Print(autodetect->log, WLOG_ERROR,
490
12
               "autodetectRspPdu->headerLength != 0x06 [0x%02" PRIx8 "]",
491
12
               autodetectRspPdu->headerLength);
492
12
    return FALSE;
493
12
  }
494
495
20
  WLog_Print(autodetect->log, WLOG_TRACE, "received RTT Measure Response PDU");
496
20
  autodetect->netCharAverageRTT =
497
20
      (UINT32)MIN(GetTickCount64() - autodetect->rttMeasureStartTime, UINT32_MAX);
498
499
20
  if (autodetect->netCharBaseRTT == 0 ||
500
20
      autodetect->netCharBaseRTT > autodetect->netCharAverageRTT)
501
20
    autodetect->netCharBaseRTT = autodetect->netCharAverageRTT;
502
503
20
  IFCALLRET(autodetect->RTTMeasureResponse, success, autodetect, transport,
504
20
            autodetectRspPdu->sequenceNumber);
505
20
  if (!success)
506
0
    WLog_Print(autodetect->log, WLOG_WARN, "RTTMeasureResponse failed");
507
20
  return success;
508
32
}
509
510
static BOOL autodetect_recv_bandwidth_measure_start(rdpAutoDetect* autodetect,
511
                                                    WINPR_ATTR_UNUSED RDP_TRANSPORT_TYPE transport,
512
                                                    WINPR_ATTR_UNUSED wStream* s,
513
                                                    const AUTODETECT_REQ_PDU* autodetectReqPdu)
514
14
{
515
14
  WINPR_ASSERT(autodetect);
516
14
  WINPR_ASSERT(s);
517
14
  WINPR_ASSERT(autodetectReqPdu);
518
519
14
  if (autodetectReqPdu->headerLength != 0x06)
520
10
  {
521
10
    WLog_Print(autodetect->log, WLOG_ERROR,
522
10
               "autodetectReqPdu->headerLength != 0x06 [0x%02" PRIx8 "]",
523
10
               autodetectReqPdu->headerLength);
524
10
    return FALSE;
525
10
  }
526
527
4
  WLog_Print(autodetect->log, WLOG_TRACE,
528
4
             "received Bandwidth Measure Start PDU - time=%" PRIu64 "", GetTickCount64());
529
  /* Initialize bandwidth measurement parameters */
530
4
  autodetect->bandwidthMeasureStartTime = GetTickCount64();
531
4
  autodetect->bandwidthMeasureByteCount = 0;
532
533
  /* Continuous Auto-Detection: mark the start of the measurement */
534
4
  if (autodetectReqPdu->requestType == RDP_BW_START_REQUEST_TYPE_CONTINUOUS)
535
2
  {
536
2
    autodetect->bandwidthMeasureStarted = TRUE;
537
2
  }
538
539
4
  return TRUE;
540
14
}
541
542
static BOOL
543
autodetect_recv_bandwidth_measure_payload(rdpAutoDetect* autodetect,
544
                                          WINPR_ATTR_UNUSED RDP_TRANSPORT_TYPE transport,
545
                                          wStream* s, const AUTODETECT_REQ_PDU* autodetectReqPdu)
546
63
{
547
63
  UINT16 payloadLength = 0;
548
549
63
  WINPR_ASSERT(autodetect);
550
63
  WINPR_ASSERT(s);
551
63
  WINPR_ASSERT(autodetectReqPdu);
552
553
63
  if (autodetectReqPdu->headerLength != 0x08)
554
10
  {
555
10
    WLog_Print(autodetect->log, WLOG_ERROR,
556
10
               "autodetectReqPdu->headerLength != 0x08 [0x%02" PRIx8 "]",
557
10
               autodetectReqPdu->headerLength);
558
10
    return FALSE;
559
10
  }
560
561
53
  if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 2))
562
2
    return FALSE;
563
564
51
  Stream_Read_UINT16(s, payloadLength); /* payloadLength (2 bytes) */
565
51
  if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, payloadLength))
566
3
    return FALSE;
567
48
  Stream_Seek(s, payloadLength);
568
569
48
  WLog_Print(autodetect->log, WLOG_DEBUG,
570
48
             "received Bandwidth Measure Payload PDU -> payloadLength=%" PRIu16 "",
571
48
             payloadLength);
572
  /* Add the payload length to the bandwidth measurement parameters */
573
48
  autodetect->bandwidthMeasureByteCount += payloadLength;
574
48
  return TRUE;
575
51
}
576
577
static BOOL autodetect_recv_bandwidth_measure_stop(rdpAutoDetect* autodetect,
578
                                                   RDP_TRANSPORT_TYPE transport, wStream* s,
579
                                                   const AUTODETECT_REQ_PDU* autodetectReqPdu)
580
158
{
581
158
  UINT16 payloadLength = 0;
582
158
  UINT16 responseType = 0;
583
584
158
  WINPR_ASSERT(autodetect);
585
158
  WINPR_ASSERT(s);
586
158
  WINPR_ASSERT(autodetectReqPdu);
587
588
158
  if (autodetectReqPdu->requestType == RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME)
589
138
  {
590
138
    if (autodetectReqPdu->headerLength != 0x08)
591
8
    {
592
8
      WLog_Print(autodetect->log, WLOG_ERROR,
593
8
                 "autodetectReqPdu->headerLength != 0x08 [0x%02" PRIx8 "]",
594
8
                 autodetectReqPdu->headerLength);
595
8
      return FALSE;
596
8
    }
597
598
130
    if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 2))
599
2
      return FALSE;
600
601
128
    Stream_Read_UINT16(s, payloadLength); /* payloadLength (2 bytes) */
602
128
  }
603
20
  else
604
20
  {
605
20
    if (autodetectReqPdu->headerLength != 0x06)
606
6
    {
607
6
      WLog_Print(autodetect->log, WLOG_ERROR,
608
6
                 "autodetectReqPdu->headerLength != 0x06 [0x%02" PRIx8 "]",
609
6
                 autodetectReqPdu->headerLength);
610
6
      return FALSE;
611
6
    }
612
613
14
    payloadLength = 0;
614
14
  }
615
616
142
  if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, payloadLength))
617
4
    return FALSE;
618
138
  Stream_Seek(s, payloadLength);
619
620
138
  WLog_Print(autodetect->log, WLOG_TRACE,
621
138
             "received Bandwidth Measure Stop PDU -> payloadLength=%" PRIu16 "", payloadLength);
622
  /* Add the payload length to the bandwidth measurement parameters */
623
138
  autodetect->bandwidthMeasureByteCount += payloadLength;
624
625
  /* Continuous Auto-Detection: mark the stop of the measurement */
626
138
  if (autodetectReqPdu->requestType == RDP_BW_STOP_REQUEST_TYPE_CONTINUOUS)
627
7
  {
628
7
    autodetect->bandwidthMeasureStarted = FALSE;
629
7
  }
630
631
  /* Send a response the server */
632
138
  responseType = autodetectReqPdu->requestType == RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME
633
138
                     ? RDP_BW_RESULTS_RESPONSE_TYPE_CONNECTTIME
634
138
                     : RDP_BW_RESULTS_RESPONSE_TYPE_CONTINUOUS;
635
138
  return autodetect_send_bandwidth_measure_results(autodetect, transport, responseType,
636
138
                                                   autodetectReqPdu->sequenceNumber);
637
142
}
638
639
static BOOL autodetect_recv_bandwidth_measure_results(rdpAutoDetect* autodetect,
640
                                                      RDP_TRANSPORT_TYPE transport, wStream* s,
641
                                                      const AUTODETECT_RSP_PDU* autodetectRspPdu)
642
24
{
643
24
  UINT32 timeDelta = 0;
644
24
  UINT32 byteCount = 0;
645
24
  BOOL success = TRUE;
646
647
24
  WINPR_ASSERT(autodetect);
648
24
  WINPR_ASSERT(s);
649
24
  WINPR_ASSERT(autodetectRspPdu);
650
651
24
  if (autodetectRspPdu->headerLength != 0x0E)
652
10
  {
653
10
    WLog_Print(autodetect->log, WLOG_ERROR,
654
10
               "autodetectRspPdu->headerLength != 0x0E [0x%02" PRIx8 "]",
655
10
               autodetectRspPdu->headerLength);
656
10
    return FALSE;
657
10
  }
658
659
14
  WLog_Print(autodetect->log, WLOG_TRACE, "received Bandwidth Measure Results PDU");
660
14
  if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 8))
661
3
    return FALSE;
662
11
  Stream_Read_UINT32(s, timeDelta); /* timeDelta (4 bytes) */
663
11
  Stream_Read_UINT32(s, byteCount); /* byteCount (4 bytes) */
664
665
11
  IFCALLRET(autodetect->BandwidthMeasureResults, success, autodetect, transport,
666
11
            autodetectRspPdu->sequenceNumber, autodetectRspPdu->responseType, timeDelta,
667
11
            byteCount);
668
11
  if (!success)
669
0
    WLog_Print(autodetect->log, WLOG_WARN, "BandwidthMeasureResults failed");
670
11
  return success;
671
14
}
672
673
static BOOL autodetect_recv_netchar_sync(rdpAutoDetect* autodetect, RDP_TRANSPORT_TYPE transport,
674
                                         wStream* s, const AUTODETECT_RSP_PDU* autodetectRspPdu)
675
16
{
676
16
  UINT32 bandwidth = 0;
677
16
  UINT32 rtt = 0;
678
16
  BOOL success = TRUE;
679
680
16
  WINPR_ASSERT(autodetect);
681
16
  WINPR_ASSERT(s);
682
16
  WINPR_ASSERT(autodetectRspPdu);
683
684
16
  if (autodetectRspPdu->headerLength != 0x0E)
685
6
  {
686
6
    WLog_Print(autodetect->log, WLOG_ERROR,
687
6
               "autodetectRspPdu->headerLength != 0x0E [0x%02" PRIx8 "]",
688
6
               autodetectRspPdu->headerLength);
689
6
    return FALSE;
690
6
  }
691
10
  if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 8))
692
2
    return FALSE;
693
694
  /* bandwidth and averageRTT fields are present (baseRTT field is not) */
695
8
  Stream_Read_UINT32(s, bandwidth); /* bandwidth (4 bytes) */
696
8
  Stream_Read_UINT32(s, rtt);       /* rtt (4 bytes) */
697
698
8
  WLog_Print(autodetect->log, WLOG_TRACE,
699
8
             "received Network Characteristics Sync PDU -> bandwidth=%" PRIu32 ", rtt=%" PRIu32
700
8
             "",
701
8
             bandwidth, rtt);
702
703
8
  IFCALLRET(autodetect->NetworkCharacteristicsSync, success, autodetect, transport,
704
8
            autodetectRspPdu->sequenceNumber, bandwidth, rtt);
705
8
  if (!success)
706
0
    WLog_Print(autodetect->log, WLOG_WARN, "NetworkCharacteristicsSync failed");
707
8
  return success;
708
10
}
709
710
static BOOL autodetect_recv_netchar_request(rdpAutoDetect* autodetect, RDP_TRANSPORT_TYPE transport,
711
                                            wStream* s, const AUTODETECT_REQ_PDU* autodetectReqPdu)
712
61
{
713
61
  rdpNetworkCharacteristicsResult result = { 0 };
714
61
  BOOL success = TRUE;
715
716
61
  WINPR_ASSERT(autodetect);
717
61
  WINPR_ASSERT(s);
718
61
  WINPR_ASSERT(autodetectReqPdu);
719
720
61
  switch (autodetectReqPdu->requestType)
721
61
  {
722
18
    case RDP_NETCHAR_RESULTS_0x0840:
723
724
      /* baseRTT and averageRTT fields are present (bandwidth field is not) */
725
18
      if (autodetectReqPdu->headerLength != 0x0E)
726
5
      {
727
5
        WLog_Print(autodetect->log, WLOG_ERROR,
728
5
                   "autodetectReqPdu->headerLength != 0x0E [0x%02" PRIx8 "]",
729
5
                   autodetectReqPdu->headerLength);
730
5
        return FALSE;
731
5
      }
732
13
      if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 8))
733
2
        return FALSE;
734
735
11
      result.type = RDP_NETCHAR_RESULT_TYPE_BASE_RTT_AVG_RTT;
736
11
      Stream_Read_UINT32(s, result.baseRTT);    /* baseRTT (4 bytes) */
737
11
      Stream_Read_UINT32(s, result.averageRTT); /* averageRTT (4 bytes) */
738
11
      break;
739
740
17
    case RDP_NETCHAR_RESULTS_0x0880:
741
742
      /* bandwidth and averageRTT fields are present (baseRTT field is not) */
743
17
      if (autodetectReqPdu->headerLength != 0x0E)
744
4
      {
745
4
        WLog_Print(autodetect->log, WLOG_ERROR,
746
4
                   "autodetectReqPdu->headerLength != 0x0E [0x%02" PRIx8 "]",
747
4
                   autodetectReqPdu->headerLength);
748
4
        return FALSE;
749
4
      }
750
13
      if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 8))
751
2
        return FALSE;
752
753
11
      result.type = RDP_NETCHAR_RESULT_TYPE_BW_AVG_RTT;
754
11
      Stream_Read_UINT32(s, result.bandwidth);  /* bandwidth (4 bytes) */
755
11
      Stream_Read_UINT32(s, result.averageRTT); /* averageRTT (4 bytes) */
756
11
      break;
757
758
26
    case RDP_NETCHAR_RESULTS_0x08C0:
759
760
      /* baseRTT, bandwidth, and averageRTT fields are present */
761
26
      if (autodetectReqPdu->headerLength != 0x12)
762
5
      {
763
5
        WLog_Print(autodetect->log, WLOG_ERROR,
764
5
                   "autodetectReqPdu->headerLength != 0x012 [0x%02" PRIx8 "]",
765
5
                   autodetectReqPdu->headerLength);
766
5
        return FALSE;
767
5
      }
768
21
      if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 12))
769
2
        return FALSE;
770
771
19
      result.type = RDP_NETCHAR_RESULT_TYPE_BASE_RTT_BW_AVG_RTT;
772
19
      Stream_Read_UINT32(s, result.baseRTT);    /* baseRTT (4 bytes) */
773
19
      Stream_Read_UINT32(s, result.bandwidth);  /* bandwidth (4 bytes) */
774
19
      Stream_Read_UINT32(s, result.averageRTT); /* averageRTT (4 bytes) */
775
19
      break;
776
777
0
    default:
778
0
      WINPR_ASSERT(FALSE);
779
0
      break;
780
61
  }
781
782
41
  WLog_Print(autodetect->log, WLOG_TRACE,
783
41
             "received Network Characteristics Result PDU -> baseRTT=%" PRIu32
784
41
             ", bandwidth=%" PRIu32 ", averageRTT=%" PRIu32 "",
785
41
             result.baseRTT, result.bandwidth, result.averageRTT);
786
787
41
  IFCALLRET(autodetect->NetworkCharacteristicsResult, success, autodetect, transport,
788
41
            autodetectReqPdu->sequenceNumber, &result);
789
41
  if (!success)
790
28
    WLog_Print(autodetect->log, WLOG_WARN, "NetworkCharacteristicsResult failed");
791
41
  return success;
792
61
}
793
794
state_run_t autodetect_recv_request_packet(rdpAutoDetect* autodetect, RDP_TRANSPORT_TYPE transport,
795
                                           wStream* s)
796
17.5k
{
797
17.5k
  AUTODETECT_REQ_PDU autodetectReqPdu = { 0 };
798
17.5k
  const rdpSettings* settings = NULL;
799
17.5k
  BOOL success = FALSE;
800
801
17.5k
  WINPR_ASSERT(autodetect);
802
17.5k
  WINPR_ASSERT(autodetect->context);
803
804
17.5k
  settings = autodetect->context->settings;
805
17.5k
  WINPR_ASSERT(settings);
806
807
17.5k
  if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 6))
808
13.0k
    return STATE_RUN_FAILED;
809
810
4.49k
  Stream_Read_UINT8(s, autodetectReqPdu.headerLength);    /* headerLength (1 byte) */
811
4.49k
  Stream_Read_UINT8(s, autodetectReqPdu.headerTypeId);    /* headerTypeId (1 byte) */
812
4.49k
  Stream_Read_UINT16(s, autodetectReqPdu.sequenceNumber); /* sequenceNumber (2 bytes) */
813
4.49k
  Stream_Read_UINT16(s, autodetectReqPdu.requestType);    /* requestType (2 bytes) */
814
815
4.49k
  if (WLog_IsLevelActive(autodetect->log, WLOG_TRACE))
816
0
  {
817
0
    char rbuffer[128] = { 0 };
818
0
    const char* requestTypeStr = autodetect_request_type_to_string_buffer(
819
0
        autodetectReqPdu.requestType, rbuffer, sizeof(rbuffer));
820
821
0
    char hbuffer[128] = { 0 };
822
0
    const char* headerStr =
823
0
        autodetect_header_type_string(autodetectReqPdu.headerTypeId, hbuffer, sizeof(hbuffer));
824
825
0
    WLog_Print(autodetect->log, WLOG_TRACE,
826
0
               "rdp_recv_autodetect_request_packet: headerLength=%" PRIu8
827
0
               ", headerTypeId=%s, sequenceNumber=%" PRIu16 ", requestType=%s",
828
0
               autodetectReqPdu.headerLength, headerStr, autodetectReqPdu.sequenceNumber,
829
0
               requestTypeStr);
830
0
  }
831
832
4.49k
  if (!freerdp_settings_get_bool(settings, FreeRDP_NetworkAutoDetect))
833
0
  {
834
0
    char rbuffer[128] = { 0 };
835
0
    const char* requestTypeStr = autodetect_request_type_to_string_buffer(
836
0
        autodetectReqPdu.requestType, rbuffer, sizeof(rbuffer));
837
838
0
    WLog_Print(autodetect->log, WLOG_WARN,
839
0
               "Received a [MS-RDPBCGR] 2.2.14.1.1 RTT Measure Request [%s] "
840
0
               "message but support was not enabled",
841
0
               requestTypeStr);
842
0
    goto fail;
843
0
  }
844
845
4.49k
  if (autodetectReqPdu.headerTypeId != TYPE_ID_AUTODETECT_REQUEST)
846
2.43k
  {
847
2.43k
    char rbuffer[128] = { 0 };
848
2.43k
    const char* requestTypeStr = autodetect_request_type_to_string_buffer(
849
2.43k
        autodetectReqPdu.requestType, rbuffer, sizeof(rbuffer));
850
2.43k
    char hbuffer[128] = { 0 };
851
2.43k
    const char* headerStr =
852
2.43k
        autodetect_header_type_string(autodetectReqPdu.headerTypeId, hbuffer, sizeof(hbuffer));
853
854
2.43k
    WLog_Print(autodetect->log, WLOG_ERROR,
855
2.43k
               "Received a [MS-RDPBCGR] 2.2.14.1.1 RTT Measure Request [%s] "
856
2.43k
               "message with invalid headerTypeId=%s",
857
2.43k
               requestTypeStr, headerStr);
858
2.43k
    goto fail;
859
2.43k
  }
860
861
2.06k
  IFCALL(autodetect->RequestReceived, autodetect, transport, autodetectReqPdu.requestType,
862
2.06k
         autodetectReqPdu.sequenceNumber);
863
2.06k
  switch (autodetectReqPdu.requestType)
864
2.06k
  {
865
22
    case RDP_RTT_REQUEST_TYPE_CONTINUOUS:
866
25
    case RDP_RTT_REQUEST_TYPE_CONNECTTIME:
867
      /* RTT Measure Request (RDP_RTT_REQUEST) - MS-RDPBCGR 2.2.14.1.1 */
868
25
      success =
869
25
          autodetect_recv_rtt_measure_request(autodetect, transport, s, &autodetectReqPdu);
870
25
      break;
871
872
9
    case RDP_BW_START_REQUEST_TYPE_CONTINUOUS:
873
11
    case RDP_BW_START_REQUEST_TYPE_TUNNEL:
874
14
    case RDP_BW_START_REQUEST_TYPE_CONNECTTIME:
875
      /* Bandwidth Measure Start (RDP_BW_START) - MS-RDPBCGR 2.2.14.1.2 */
876
14
      success = autodetect_recv_bandwidth_measure_start(autodetect, transport, s,
877
14
                                                        &autodetectReqPdu);
878
14
      break;
879
880
63
    case RDP_BW_PAYLOAD_REQUEST_TYPE:
881
      /* Bandwidth Measure Payload (RDP_BW_PAYLOAD) - MS-RDPBCGR 2.2.14.1.3 */
882
63
      success = autodetect_recv_bandwidth_measure_payload(autodetect, transport, s,
883
63
                                                          &autodetectReqPdu);
884
63
      break;
885
886
138
    case RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME:
887
150
    case RDP_BW_STOP_REQUEST_TYPE_CONTINUOUS:
888
158
    case RDP_BW_STOP_REQUEST_TYPE_TUNNEL:
889
      /* Bandwidth Measure Stop (RDP_BW_STOP) - MS-RDPBCGR 2.2.14.1.4 */
890
158
      success =
891
158
          autodetect_recv_bandwidth_measure_stop(autodetect, transport, s, &autodetectReqPdu);
892
158
      break;
893
894
18
    case RDP_NETCHAR_RESULTS_0x0840:
895
35
    case RDP_NETCHAR_RESULTS_0x0880:
896
61
    case RDP_NETCHAR_RESULTS_0x08C0:
897
      /* Network Characteristics Result (RDP_NETCHAR_RESULT) - MS-RDPBCGR 2.2.14.1.5 */
898
61
      success = autodetect_recv_netchar_request(autodetect, transport, s, &autodetectReqPdu);
899
61
      break;
900
901
1.74k
    default:
902
1.74k
      WLog_Print(autodetect->log, WLOG_ERROR, "Unknown requestType=0x%04" PRIx16,
903
1.74k
                 autodetectReqPdu.requestType);
904
1.74k
      break;
905
2.06k
  }
906
907
4.49k
fail:
908
4.49k
  if (success)
909
65
    autodetect->state = FREERDP_AUTODETECT_STATE_REQUEST;
910
4.43k
  else
911
4.43k
    autodetect->state = FREERDP_AUTODETECT_STATE_FAIL;
912
4.49k
  return success ? STATE_RUN_SUCCESS : STATE_RUN_FAILED;
913
2.06k
}
914
915
state_run_t autodetect_recv_response_packet(rdpAutoDetect* autodetect, RDP_TRANSPORT_TYPE transport,
916
                                            wStream* s)
917
17.5k
{
918
17.5k
  AUTODETECT_RSP_PDU autodetectRspPdu = { 0 };
919
17.5k
  const rdpSettings* settings = NULL;
920
17.5k
  BOOL success = FALSE;
921
922
17.5k
  WINPR_ASSERT(autodetect);
923
17.5k
  WINPR_ASSERT(autodetect->context);
924
17.5k
  WINPR_ASSERT(s);
925
926
17.5k
  settings = autodetect->context->settings;
927
17.5k
  WINPR_ASSERT(settings);
928
929
17.5k
  if (!Stream_CheckAndLogRequiredLengthWLog(autodetect->log, s, 6))
930
13.5k
    goto fail;
931
932
3.99k
  Stream_Read_UINT8(s, autodetectRspPdu.headerLength);    /* headerLength (1 byte) */
933
3.99k
  Stream_Read_UINT8(s, autodetectRspPdu.headerTypeId);    /* headerTypeId (1 byte) */
934
3.99k
  Stream_Read_UINT16(s, autodetectRspPdu.sequenceNumber); /* sequenceNumber (2 bytes) */
935
3.99k
  Stream_Read_UINT16(s, autodetectRspPdu.responseType);   /* responseType (2 bytes) */
936
937
3.99k
  if (WLog_IsLevelActive(autodetect->log, WLOG_TRACE))
938
0
  {
939
0
    char rbuffer[128] = { 0 };
940
0
    const char* requestStr = autodetect_request_type_to_string_buffer(
941
0
        autodetectRspPdu.responseType, rbuffer, sizeof(rbuffer));
942
0
    char hbuffer[128] = { 0 };
943
0
    const char* headerStr =
944
0
        autodetect_header_type_string(autodetectRspPdu.headerTypeId, hbuffer, sizeof(hbuffer));
945
946
0
    WLog_Print(autodetect->log, WLOG_TRACE,
947
0
               "rdp_recv_autodetect_response_packet: headerLength=%" PRIu8 ", headerTypeId=%s"
948
0
               ", sequenceNumber=%" PRIu16 ", requestType=%s",
949
0
               autodetectRspPdu.headerLength, headerStr, autodetectRspPdu.sequenceNumber,
950
0
               requestStr);
951
0
  }
952
953
3.99k
  if (!freerdp_settings_get_bool(settings, FreeRDP_NetworkAutoDetect))
954
0
  {
955
0
    char rbuffer[128] = { 0 };
956
957
0
    const char* requestStr = autodetect_request_type_to_string_buffer(
958
0
        autodetectRspPdu.responseType, rbuffer, sizeof(rbuffer));
959
960
0
    WLog_Print(autodetect->log, WLOG_WARN,
961
0
               "Received a [MS-RDPBCGR] 2.2.14.2.1 RTT Measure Response [%s] "
962
0
               "message but support was not enabled",
963
0
               requestStr);
964
0
    return STATE_RUN_FAILED;
965
0
  }
966
967
3.99k
  if (autodetectRspPdu.headerTypeId != TYPE_ID_AUTODETECT_RESPONSE)
968
3.85k
  {
969
3.85k
    char rbuffer[128] = { 0 };
970
3.85k
    const char* requestStr = autodetect_request_type_to_string_buffer(
971
3.85k
        autodetectRspPdu.responseType, rbuffer, sizeof(rbuffer));
972
3.85k
    char hbuffer[128] = { 0 };
973
3.85k
    const char* headerStr =
974
3.85k
        autodetect_header_type_string(autodetectRspPdu.headerTypeId, hbuffer, sizeof(hbuffer));
975
3.85k
    WLog_Print(autodetect->log, WLOG_ERROR,
976
3.85k
               "Received a [MS-RDPBCGR] 2.2.14.2.1 RTT Measure Response [%s] "
977
3.85k
               "message with invalid headerTypeId=%s",
978
3.85k
               requestStr, headerStr);
979
3.85k
    goto fail;
980
3.85k
  }
981
982
139
  IFCALL(autodetect->ResponseReceived, autodetect, transport, autodetectRspPdu.responseType,
983
139
         autodetectRspPdu.sequenceNumber);
984
139
  switch (autodetectRspPdu.responseType)
985
139
  {
986
32
    case RDP_RTT_RESPONSE_TYPE:
987
      /* RTT Measure Response (RDP_RTT_RESPONSE) - MS-RDPBCGR 2.2.14.2.1 */
988
32
      success =
989
32
          autodetect_recv_rtt_measure_response(autodetect, transport, s, &autodetectRspPdu);
990
32
      break;
991
992
20
    case RDP_BW_RESULTS_RESPONSE_TYPE_CONNECTTIME:
993
24
    case RDP_BW_RESULTS_RESPONSE_TYPE_CONTINUOUS:
994
      /* Bandwidth Measure Results (RDP_BW_RESULTS) - MS-RDPBCGR 2.2.14.2.2 */
995
24
      success = autodetect_recv_bandwidth_measure_results(autodetect, transport, s,
996
24
                                                          &autodetectRspPdu);
997
24
      break;
998
999
16
    case RDP_NETCHAR_SYNC_RESPONSE_TYPE:
1000
      /* Network Characteristics Sync (RDP_NETCHAR_SYNC) - MS-RDPBCGR 2.2.14.2.3 */
1001
16
      success = autodetect_recv_netchar_sync(autodetect, transport, s, &autodetectRspPdu);
1002
16
      break;
1003
1004
67
    default:
1005
67
      WLog_Print(autodetect->log, WLOG_ERROR, "Unknown responseType=0x%04" PRIx16,
1006
67
                 autodetectRspPdu.responseType);
1007
67
      break;
1008
139
  }
1009
1010
17.5k
fail:
1011
17.5k
  if (success)
1012
39
  {
1013
39
    if (autodetectRspPdu.responseType == RDP_BW_RESULTS_RESPONSE_TYPE_CONNECTTIME)
1014
10
      autodetect->state = FREERDP_AUTODETECT_STATE_COMPLETE;
1015
29
    else
1016
29
      autodetect->state = FREERDP_AUTODETECT_STATE_RESPONSE;
1017
39
  }
1018
17.5k
  else
1019
17.5k
    autodetect->state = FREERDP_AUTODETECT_STATE_FAIL;
1020
1021
17.5k
  return success ? STATE_RUN_SUCCESS : STATE_RUN_FAILED;
1022
139
}
1023
1024
void autodetect_on_connect_time_auto_detect_begin(rdpAutoDetect* autodetect)
1025
0
{
1026
0
  WINPR_ASSERT(autodetect);
1027
0
  WINPR_ASSERT(autodetect->OnConnectTimeAutoDetectBegin);
1028
1029
0
  autodetect->state = autodetect->OnConnectTimeAutoDetectBegin(autodetect);
1030
0
}
1031
1032
void autodetect_on_connect_time_auto_detect_progress(rdpAutoDetect* autodetect)
1033
0
{
1034
0
  WINPR_ASSERT(autodetect);
1035
0
  WINPR_ASSERT(autodetect->OnConnectTimeAutoDetectProgress);
1036
1037
0
  autodetect->state = autodetect->OnConnectTimeAutoDetectProgress(autodetect);
1038
0
}
1039
1040
rdpAutoDetect* autodetect_new(rdpContext* context)
1041
17.5k
{
1042
17.5k
  rdpAutoDetect* autoDetect = (rdpAutoDetect*)calloc(1, sizeof(rdpAutoDetect));
1043
17.5k
  if (!autoDetect)
1044
0
    return NULL;
1045
17.5k
  autoDetect->context = context;
1046
17.5k
  autoDetect->log = WLog_Get(AUTODETECT_TAG);
1047
1048
17.5k
  return autoDetect;
1049
17.5k
}
1050
1051
void autodetect_free(rdpAutoDetect* autoDetect)
1052
17.5k
{
1053
17.5k
  free(autoDetect);
1054
17.5k
}
1055
1056
void autodetect_register_server_callbacks(rdpAutoDetect* autodetect)
1057
8.50k
{
1058
8.50k
  WINPR_ASSERT(autodetect);
1059
1060
8.50k
  autodetect->RTTMeasureRequest = autodetect_send_rtt_measure_request;
1061
8.50k
  autodetect->BandwidthMeasureStart = autodetect_send_bandwidth_measure_start;
1062
8.50k
  autodetect->BandwidthMeasurePayload = autodetect_send_bandwidth_measure_payload;
1063
8.50k
  autodetect->BandwidthMeasureStop = autodetect_send_bandwidth_measure_stop;
1064
8.50k
  autodetect->NetworkCharacteristicsResult = autodetect_send_netchar_result;
1065
1066
  /*
1067
   * Default handlers for Connect-Time Auto-Detection
1068
   * (MAY be overridden by the API user)
1069
   */
1070
8.50k
  autodetect->OnConnectTimeAutoDetectBegin = autodetect_on_connect_time_auto_detect_begin_default;
1071
8.50k
  autodetect->OnConnectTimeAutoDetectProgress =
1072
8.50k
      autodetect_on_connect_time_auto_detect_progress_default;
1073
8.50k
}
1074
1075
FREERDP_AUTODETECT_STATE autodetect_get_state(rdpAutoDetect* autodetect)
1076
0
{
1077
0
  WINPR_ASSERT(autodetect);
1078
0
  return autodetect->state;
1079
0
}
1080
1081
rdpAutoDetect* autodetect_get(rdpContext* context)
1082
0
{
1083
0
  WINPR_ASSERT(context);
1084
0
  WINPR_ASSERT(context->rdp);
1085
0
  return context->rdp->autodetect;
1086
0
}