FreeRDP
Loading...
Searching...
No Matches
client/location_main.c
1
21#include <freerdp/config.h>
22
23#include <stdio.h>
24#include <stdlib.h>
25#include <float.h>
26#include <math.h>
27
28#include <winpr/crt.h>
29#include <winpr/assert.h>
30#include <winpr/cast.h>
31#include <winpr/stream.h>
32
33#include <freerdp/client/channels.h>
34#include <freerdp/channels/log.h>
35#include <freerdp/channels/location.h>
36#include <freerdp/client/location.h>
37#include <freerdp/utils/encoded_types.h>
38
39#define TAG CHANNELS_TAG("location.client")
40
41/* implement [MS-RDPEL]
42 * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpel/4397a0af-c821-4b75-9068-476fb579c327
43 */
44typedef struct
45{
46 GENERIC_DYNVC_PLUGIN baseDynPlugin;
47 LocationClientContext context;
48} LOCATION_PLUGIN;
49
50typedef struct
51{
52 GENERIC_CHANNEL_CALLBACK baseCb;
53 UINT32 serverVersion;
54 UINT32 clientVersion;
55 UINT32 serverFlags;
56 UINT32 clientFlags;
57} LOCATION_CALLBACK;
58
59static BOOL location_read_header(wLog* log, wStream* s, UINT16* ppduType, UINT32* ppduLength)
60{
61 WINPR_ASSERT(log);
62 WINPR_ASSERT(s);
63 WINPR_ASSERT(ppduType);
64 WINPR_ASSERT(ppduLength);
65
66 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 6))
67 return FALSE;
68 Stream_Read_UINT16(s, *ppduType);
69 Stream_Read_UINT32(s, *ppduLength);
70 if (*ppduLength < 6)
71 {
72 WLog_Print(log, WLOG_ERROR,
73 "RDPLOCATION_HEADER::pduLengh=%" PRIu16 " < sizeof(RDPLOCATION_HEADER)[6]",
74 *ppduLength);
75 return FALSE;
76 }
77 return Stream_CheckAndLogRequiredLengthWLog(log, s, *ppduLength - 6ull);
78}
79
80static BOOL location_write_header(wStream* s, UINT16 pduType, UINT32 pduLength)
81{
82 if (!Stream_EnsureRemainingCapacity(s, 6))
83 return FALSE;
84 Stream_Write_UINT16(s, pduType);
85 Stream_Write_UINT32(s, pduLength + 6);
86 return Stream_EnsureRemainingCapacity(s, pduLength);
87}
88
89static BOOL location_read_server_ready_pdu(LOCATION_CALLBACK* callback, wStream* s, UINT32 pduSize)
90{
91 if (pduSize < 6 + 4)
92 return FALSE; // Short message
93
94 Stream_Read_UINT32(s, callback->serverVersion);
95 if (pduSize >= 6 + 4 + 4)
96 Stream_Read_UINT32(s, callback->serverFlags);
97 return TRUE;
98}
99
100static UINT location_channel_send(IWTSVirtualChannel* channel, wStream* s)
101{
102 const size_t len = Stream_GetPosition(s);
103 if (len > UINT32_MAX)
104 return ERROR_INTERNAL_ERROR;
105
106 Stream_SetPosition(s, 2);
107 Stream_Write_UINT32(s, (UINT32)len);
108
109 WINPR_ASSERT(channel);
110 WINPR_ASSERT(channel->Write);
111 return channel->Write(channel, (UINT32)len, Stream_Buffer(s), NULL);
112}
113
114static UINT location_send_client_ready_pdu(const LOCATION_CALLBACK* callback)
115{
116 wStream sbuffer = { 0 };
117 BYTE buffer[32] = { 0 };
118 wStream* s = Stream_StaticInit(&sbuffer, buffer, sizeof(buffer));
119 WINPR_ASSERT(s);
120
121 if (!location_write_header(s, PDUTYPE_CLIENT_READY, 8))
122 return ERROR_OUTOFMEMORY;
123
124 Stream_Write_UINT32(s, callback->clientVersion);
125 Stream_Write_UINT32(s, callback->clientFlags);
126 return location_channel_send(callback->baseCb.channel, s);
127}
128
129static const char* location_version_str(UINT32 version, char* buffer, size_t size)
130{
131 const char* str = NULL;
132 switch (version)
133 {
134 case RDPLOCATION_PROTOCOL_VERSION_100:
135 str = "RDPLOCATION_PROTOCOL_VERSION_100";
136 break;
137 case RDPLOCATION_PROTOCOL_VERSION_200:
138 str = "RDPLOCATION_PROTOCOL_VERSION_200";
139 break;
140 default:
141 str = "RDPLOCATION_PROTOCOL_VERSION_UNKNOWN";
142 break;
143 }
144
145 (void)_snprintf(buffer, size, "%s [0x%08" PRIx32 "]", str, version);
146 return buffer;
147}
148
154static UINT location_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
155{
156 LOCATION_CALLBACK* callback = (LOCATION_CALLBACK*)pChannelCallback;
157
158 WINPR_ASSERT(callback);
159
160 LOCATION_PLUGIN* plugin = (LOCATION_PLUGIN*)callback->baseCb.plugin;
161 WINPR_ASSERT(plugin);
162
163 UINT16 pduType = 0;
164 UINT32 pduLength = 0;
165 if (!location_read_header(plugin->baseDynPlugin.log, data, &pduType, &pduLength))
166 return ERROR_INVALID_DATA;
167
168 switch (pduType)
169 {
170 case PDUTYPE_SERVER_READY:
171 if (!location_read_server_ready_pdu(callback, data, pduLength))
172 return ERROR_INVALID_DATA;
173
174 switch (callback->serverVersion)
175 {
176 case RDPLOCATION_PROTOCOL_VERSION_200:
177 callback->clientVersion = RDPLOCATION_PROTOCOL_VERSION_200;
178 break;
179 case RDPLOCATION_PROTOCOL_VERSION_100:
180 callback->clientVersion = RDPLOCATION_PROTOCOL_VERSION_100;
181 break;
182 default:
183 callback->clientVersion = RDPLOCATION_PROTOCOL_VERSION_100;
184 if (callback->serverVersion > RDPLOCATION_PROTOCOL_VERSION_200)
185 callback->clientVersion = RDPLOCATION_PROTOCOL_VERSION_200;
186 break;
187 }
188
189 {
190 char cbuffer[64] = { 0 };
191 char sbuffer[64] = { 0 };
192 WLog_Print(plugin->baseDynPlugin.log, WLOG_DEBUG,
193 "Server version %s, client version %s",
194 location_version_str(callback->serverVersion, sbuffer, sizeof(sbuffer)),
195 location_version_str(callback->clientVersion, cbuffer, sizeof(cbuffer)));
196 }
197
198 if (!plugin->context.LocationStart)
199 {
200 WLog_Print(plugin->baseDynPlugin.log, WLOG_WARN,
201 "LocationStart=NULL, no location data will be sent");
202 return CHANNEL_RC_OK;
203 }
204
205 {
206 const UINT res =
207 plugin->context.LocationStart(&plugin->context, callback->clientVersion, 0);
208 if (res != CHANNEL_RC_OK)
209 return res;
210 }
211 return location_send_client_ready_pdu(callback);
212 default:
213 WLog_WARN(TAG, "invalid pduType=%s");
214 return ERROR_INVALID_DATA;
215 }
216}
217
218static UINT location_send_base_location3d(IWTSVirtualChannel* channel,
219 const RDPLOCATION_BASE_LOCATION3D_PDU* pdu)
220{
221 wStream sbuffer = { 0 };
222 BYTE buffer[32] = { 0 };
223 wStream* s = Stream_StaticInit(&sbuffer, buffer, sizeof(buffer));
224 WINPR_ASSERT(s);
225 WINPR_ASSERT(channel);
226 WINPR_ASSERT(pdu);
227
228 if (pdu->source)
229 WLog_DBG(TAG,
230 "latitude=%lf, longitude=%lf, altitude=%" PRId32
231 ", speed=%lf, heading=%lf, haccuracy=%lf, source=%" PRIu8,
232 pdu->latitude, pdu->longitude, pdu->altitude, pdu->speed, pdu->heading,
233 pdu->horizontalAccuracy, *pdu->source);
234 else
235 WLog_DBG(TAG, "latitude=%lf, longitude=%lf, altitude=%" PRId32, pdu->latitude,
236 pdu->longitude, pdu->altitude);
237
238 if (!location_write_header(s, PDUTYPE_BASE_LOCATION3D, pdu->source ? 25 : 12))
239 return ERROR_OUTOFMEMORY;
240
241 if (!freerdp_write_four_byte_float(s, pdu->latitude) ||
242 !freerdp_write_four_byte_float(s, pdu->longitude) ||
243 !freerdp_write_four_byte_signed_integer(s, pdu->altitude))
244 return ERROR_INTERNAL_ERROR;
245
246 if (pdu->source)
247 {
248 if (!freerdp_write_four_byte_float(s, *pdu->speed) ||
249 !freerdp_write_four_byte_float(s, *pdu->heading) ||
250 !freerdp_write_four_byte_float(s, *pdu->horizontalAccuracy))
251 return ERROR_INTERNAL_ERROR;
252
253 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(UINT8, *pdu->source));
254 }
255
256 return location_channel_send(channel, s);
257}
258
259static UINT location_send_location2d_delta(IWTSVirtualChannel* channel,
260 const RDPLOCATION_LOCATION2D_DELTA_PDU* pdu)
261{
262 wStream sbuffer = { 0 };
263 BYTE buffer[32] = { 0 };
264 wStream* s = Stream_StaticInit(&sbuffer, buffer, sizeof(buffer));
265 WINPR_ASSERT(s);
266
267 WINPR_ASSERT(channel);
268 WINPR_ASSERT(pdu);
269
270 const BOOL ext = pdu->speedDelta && pdu->headingDelta;
271
272 if (ext)
273 WLog_DBG(TAG, "latitude=%lf, longitude=%lf, speed=%lf, heading=%lf", pdu->latitudeDelta,
274 pdu->longitudeDelta, pdu->speedDelta, pdu->headingDelta);
275 else
276 WLog_DBG(TAG, "latitude=%lf, longitude=%lf", pdu->latitudeDelta, pdu->longitudeDelta);
277
278 if (!location_write_header(s, PDUTYPE_LOCATION2D_DELTA, ext ? 16 : 8))
279 return ERROR_OUTOFMEMORY;
280
281 if (!freerdp_write_four_byte_float(s, pdu->latitudeDelta) ||
282 !freerdp_write_four_byte_float(s, pdu->longitudeDelta))
283 return ERROR_INTERNAL_ERROR;
284
285 if (ext)
286 {
287 if (!freerdp_write_four_byte_float(s, *pdu->speedDelta) ||
288 !freerdp_write_four_byte_float(s, *pdu->headingDelta))
289 return ERROR_INTERNAL_ERROR;
290 }
291
292 return location_channel_send(channel, s);
293}
294
295static UINT location_send_location3d_delta(IWTSVirtualChannel* channel,
296 const RDPLOCATION_LOCATION3D_DELTA_PDU* pdu)
297{
298 wStream sbuffer = { 0 };
299 BYTE buffer[32] = { 0 };
300 wStream* s = Stream_StaticInit(&sbuffer, buffer, sizeof(buffer));
301 WINPR_ASSERT(s);
302
303 WINPR_ASSERT(channel);
304 WINPR_ASSERT(pdu);
305
306 const BOOL ext = pdu->speedDelta && pdu->headingDelta;
307
308 if (ext)
309 WLog_DBG(TAG, "latitude=%lf, longitude=%lf, altitude=%" PRId32 ", speed=%lf, heading=%lf",
310 pdu->latitudeDelta, pdu->longitudeDelta, pdu->altitudeDelta, pdu->speedDelta,
311 pdu->headingDelta);
312 else
313 WLog_DBG(TAG, "latitude=%lf, longitude=%lf, altitude=%" PRId32, pdu->latitudeDelta,
314 pdu->longitudeDelta, pdu->altitudeDelta);
315
316 if (!location_write_header(s, PDUTYPE_LOCATION3D_DELTA, ext ? 20 : 12))
317 return ERROR_OUTOFMEMORY;
318
319 if (!freerdp_write_four_byte_float(s, pdu->latitudeDelta) ||
320 !freerdp_write_four_byte_float(s, pdu->longitudeDelta) ||
321 !freerdp_write_four_byte_signed_integer(s, pdu->altitudeDelta))
322 return ERROR_INTERNAL_ERROR;
323
324 if (ext)
325 {
326 if (!freerdp_write_four_byte_float(s, *pdu->speedDelta) ||
327 !freerdp_write_four_byte_float(s, *pdu->headingDelta))
328 return ERROR_INTERNAL_ERROR;
329 }
330
331 return location_channel_send(channel, s);
332}
333
334static UINT location_send(LocationClientContext* context, LOCATION_PDUTYPE type, size_t count, ...)
335{
336 WINPR_ASSERT(context);
337
338 LOCATION_PLUGIN* loc = context->handle;
339 WINPR_ASSERT(loc);
340
341 GENERIC_LISTENER_CALLBACK* cb = loc->baseDynPlugin.listener_callback;
342 WINPR_ASSERT(cb);
343
344 IWTSVirtualChannel* channel = cb->channel;
345 WINPR_ASSERT(channel);
346
347 const LOCATION_CALLBACK* callback =
348 (const LOCATION_CALLBACK*)loc->baseDynPlugin.channel_callbacks;
349 WINPR_ASSERT(callback);
350
351 UINT32 res = ERROR_INTERNAL_ERROR;
352 va_list ap = { 0 };
353 va_start(ap, count);
354 switch (type)
355 {
356 case PDUTYPE_BASE_LOCATION3D:
357 if ((count != 3) && (count != 7))
358 res = ERROR_INVALID_PARAMETER;
359 else
360 {
361 RDPLOCATION_BASE_LOCATION3D_PDU pdu = { 0 };
362 LOCATIONSOURCE source = LOCATIONSOURCE_IP;
363 double speed = FP_NAN;
364 double heading = FP_NAN;
365 double horizontalAccuracy = FP_NAN;
366 pdu.latitude = va_arg(ap, double);
367 pdu.longitude = va_arg(ap, double);
368 pdu.altitude = va_arg(ap, INT32);
369 if ((count > 3) && (callback->clientVersion >= RDPLOCATION_PROTOCOL_VERSION_200))
370 {
371 speed = va_arg(ap, double);
372 heading = va_arg(ap, double);
373 horizontalAccuracy = va_arg(ap, double);
374 source = WINPR_ASSERTING_INT_CAST(LOCATIONSOURCE, va_arg(ap, int));
375 pdu.speed = &speed;
376 pdu.heading = &heading;
377 pdu.horizontalAccuracy = &horizontalAccuracy;
378 pdu.source = &source;
379 }
380 res = location_send_base_location3d(channel, &pdu);
381 }
382 break;
383 case PDUTYPE_LOCATION2D_DELTA:
384 if ((count != 2) && (count != 4))
385 res = ERROR_INVALID_PARAMETER;
386 else
387 {
388 RDPLOCATION_LOCATION2D_DELTA_PDU pdu = { 0 };
389
390 pdu.latitudeDelta = va_arg(ap, double);
391 pdu.longitudeDelta = va_arg(ap, double);
392
393 double speedDelta = FP_NAN;
394 double headingDelta = FP_NAN;
395 if ((count > 2) && (callback->clientVersion >= RDPLOCATION_PROTOCOL_VERSION_200))
396 {
397 speedDelta = va_arg(ap, double);
398 headingDelta = va_arg(ap, double);
399 pdu.speedDelta = &speedDelta;
400 pdu.headingDelta = &headingDelta;
401 }
402 res = location_send_location2d_delta(channel, &pdu);
403 }
404 break;
405 case PDUTYPE_LOCATION3D_DELTA:
406 if ((count != 3) && (count != 5))
407 res = ERROR_INVALID_PARAMETER;
408 else
409 {
410 RDPLOCATION_LOCATION3D_DELTA_PDU pdu = { 0 };
411 double speedDelta = FP_NAN;
412 double headingDelta = FP_NAN;
413
414 pdu.latitudeDelta = va_arg(ap, double);
415 pdu.longitudeDelta = va_arg(ap, double);
416 pdu.altitudeDelta = va_arg(ap, INT32);
417 if ((count > 3) && (callback->clientVersion >= RDPLOCATION_PROTOCOL_VERSION_200))
418 {
419 speedDelta = va_arg(ap, double);
420 headingDelta = va_arg(ap, double);
421 pdu.speedDelta = &speedDelta;
422 pdu.headingDelta = &headingDelta;
423 }
424 res = location_send_location3d_delta(channel, &pdu);
425 }
426 break;
427 default:
428 res = ERROR_INVALID_PARAMETER;
429 break;
430 }
431 va_end(ap);
432 return res;
433}
434
440static UINT location_on_close(IWTSVirtualChannelCallback* pChannelCallback)
441{
442 UINT res = CHANNEL_RC_OK;
443 GENERIC_CHANNEL_CALLBACK* callback = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
444
445 if (callback)
446 {
447 LOCATION_PLUGIN* plugin = (LOCATION_PLUGIN*)callback->plugin;
448 WINPR_ASSERT(plugin);
449
450 res = IFCALLRESULT(CHANNEL_RC_OK, plugin->context.LocationStop, &plugin->context);
451 }
452 free(callback);
453
454 return res;
455}
456
457static UINT location_init(GENERIC_DYNVC_PLUGIN* plugin, WINPR_ATTR_UNUSED rdpContext* context,
458 WINPR_ATTR_UNUSED rdpSettings* settings)
459{
460 LOCATION_PLUGIN* loc = (LOCATION_PLUGIN*)plugin;
461
462 WINPR_ASSERT(loc);
463
464 loc->context.LocationSend = location_send;
465 loc->context.handle = loc;
466 plugin->iface.pInterface = &loc->context;
467 return CHANNEL_RC_OK;
468}
469
470static const IWTSVirtualChannelCallback location_callbacks = { location_on_data_received,
471 NULL, /* Open */
472 location_on_close, NULL };
473
479FREERDP_ENTRY_POINT(UINT VCAPITYPE location_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))
480{
481 return freerdp_generic_DVCPluginEntry(pEntryPoints, TAG, LOCATION_DVC_CHANNEL_NAME,
482 sizeof(LOCATION_PLUGIN), sizeof(LOCATION_CALLBACK),
483 &location_callbacks, location_init, NULL);
484}
RDPLOCATION_BASE_LOCATION3D_PDU
Definition channels/location.h:93
RDPLOCATION_LOCATION2D_DELTA_PDU
Definition channels/location.h:105
RDPLOCATION_LOCATION3D_DELTA_PDU
Definition channels/location.h:114
GENERIC_CHANNEL_CALLBACK
Definition include/freerdp/client/channels.h:35
GENERIC_DYNVC_PLUGIN
Definition include/freerdp/client/channels.h:57
GENERIC_LISTENER_CALLBACK
Definition include/freerdp/client/channels.h:43