FreeRDP
Loading...
Searching...
No Matches
pf_channel_drdynvc.c
1
19#include <winpr/assert.h>
20
21#include <freerdp/channels/drdynvc.h>
22#include <freerdp/utils/drdynvc.h>
23#include <freerdp/server/proxy/proxy_log.h>
24
25#include "pf_channel_drdynvc.h"
26#include "../pf_channel.h"
27#include "../proxy_modules.h"
28#include "../pf_utils.h"
29#include "../pf_server.h"
30
31#define DTAG PROXY_TAG("drdynvc")
32
33#define Stream_CheckAndLogRequiredLengthWLogWithBackend(log, s, nmemb, backdata) \
34 Stream_CheckAndLogRequiredLengthWLogEx(log, WLOG_WARN, s, nmemb, 1, "%s(%s:%" PRIuz ")[%s]", \
35 __func__, __FILE__, (size_t)__LINE__, \
36 getDirection(backdata))
37
39typedef enum
40{
41 CHANNEL_OPENSTATE_WAITING_OPEN_STATUS,
42 CHANNEL_OPENSTATE_OPENED,
43 CHANNEL_OPENSTATE_CLOSED
44} PfDynChannelOpenStatus;
45
46typedef struct p_server_dynamic_channel_context pServerDynamicChannelContext;
47typedef struct DynChannelTrackerState DynChannelTrackerState;
48
49typedef PfChannelResult (*dynamic_channel_on_data_fn)(pServerContext* ps,
50 pServerDynamicChannelContext* channel,
51 BOOL isBackData, ChannelStateTracker* tracker,
52 BOOL firstPacket, BOOL lastPacket);
53
55struct DynChannelTrackerState
56{
57 UINT32 currentDataLength;
58 UINT32 CurrentDataReceived;
59 UINT32 CurrentDataFragments;
60 wStream* currentPacket;
61 WINPR_ATTR_NODISCARD dynamic_channel_on_data_fn dataCallback;
62};
63
64typedef void (*channel_data_dtor_fn)(void** user_data);
65
66struct p_server_dynamic_channel_context
67{
68 char* channelName;
69 UINT32 channelId;
70 PfDynChannelOpenStatus openStatus;
71 pf_utils_channel_mode channelMode;
72 BOOL packetReassembly;
73 DynChannelTrackerState backTracker;
74 DynChannelTrackerState frontTracker;
75
76 void* channelData;
77 channel_data_dtor_fn channelDataDtor;
78};
79
81typedef struct
82{
83 wHashTable* channels;
84 ChannelStateTracker* backTracker;
85 ChannelStateTracker* frontTracker;
86 wLog* log;
87} DynChannelContext;
88
90typedef enum
91{
92 DYNCVC_READ_OK,
93 DYNCVC_READ_ERROR,
94 DYNCVC_READ_INCOMPLETE
95} DynvcReadResult;
96
97static const char* openstatus2str(PfDynChannelOpenStatus status)
98{
99 switch (status)
100 {
101 case CHANNEL_OPENSTATE_WAITING_OPEN_STATUS:
102 return "CHANNEL_OPENSTATE_WAITING_OPEN_STATUS";
103 case CHANNEL_OPENSTATE_CLOSED:
104 return "CHANNEL_OPENSTATE_CLOSED";
105 case CHANNEL_OPENSTATE_OPENED:
106 return "CHANNEL_OPENSTATE_OPENED";
107 default:
108 return "CHANNEL_OPENSTATE_UNKNOWN";
109 }
110}
111
112#define DynvcTrackerLog(log, level, dynChannel, cmd, isBackData, ...) \
113 dyn_log_((log), (level), (dynChannel), (cmd), (isBackData), __func__, __FILE__, __LINE__, \
114 __VA_ARGS__)
115
116WINPR_ATTR_NODISCARD
117static const char* getDirection(BOOL isBackData)
118{
119 return isBackData ? "B->F" : "F->B";
120}
121
122static void dyn_log_(wLog* log, DWORD level, const pServerDynamicChannelContext* dynChannel,
123 BYTE cmd, BOOL isBackData, const char* fkt, const char* file, size_t line,
124 const char* fmt, ...)
125{
126 if (!WLog_IsLevelActive(log, level))
127 return;
128
129 char* prefix = nullptr;
130 char* msg = nullptr;
131 size_t prefixlen = 0;
132 size_t msglen = 0;
133
134 uint32_t channelId = dynChannel ? dynChannel->channelId : UINT32_MAX;
135 const char* channelName = dynChannel ? dynChannel->channelName : "<nullptr>";
136 (void)winpr_asprintf(&prefix, &prefixlen, "DynvcTracker[%s](%s [%s:%" PRIu32 "])",
137 getDirection(isBackData), channelName, drdynvc_get_packet_type(cmd),
138 channelId);
139
140 va_list ap = WINPR_C_ARRAY_INIT;
141 va_start(ap, fmt);
142 (void)winpr_vasprintf(&msg, &msglen, fmt, ap);
143 va_end(ap);
144
145 WLog_PrintTextMessage(log, level, line, file, fkt, "%s: %s", prefix, msg);
146 free(prefix);
147 free(msg);
148}
149
150WINPR_ATTR_NODISCARD
151static PfChannelResult data_cb(pServerContext* ps, pServerDynamicChannelContext* channel,
152 BOOL isBackData, ChannelStateTracker* tracker, BOOL firstPacket,
153 BOOL lastPacket)
154{
155 WINPR_ASSERT(ps);
156 WINPR_ASSERT(channel);
157 WINPR_ASSERT(tracker);
158 WINPR_ASSERT(ps->pdata);
159
160 wStream* currentPacket = channelTracker_getCurrentPacket(tracker);
161 proxyDynChannelInterceptData dyn = { .name = channel->channelName,
162 .channelId = channel->channelId,
163 .data = currentPacket,
164 .isBackData = isBackData,
165 .first = firstPacket,
166 .last = lastPacket,
167 .rewritten = FALSE,
168 .packetSize = channelTracker_getCurrentPacketSize(tracker),
169 .result = PF_CHANNEL_RESULT_ERROR };
170 Stream_SealLength(dyn.data);
171 if (!pf_modules_run_filter(ps->pdata->module, FILTER_TYPE_INTERCEPT_CHANNEL, ps->pdata, &dyn))
172 return PF_CHANNEL_RESULT_ERROR;
173
174 channelTracker_setCurrentPacketSize(tracker, dyn.packetSize);
175 if (dyn.rewritten)
176 return channelTracker_flushCurrent(tracker, firstPacket, lastPacket, !isBackData);
177 return dyn.result;
178}
179
180static void DynamicChannelContext_free(void* ptr)
181{
182 pServerDynamicChannelContext* c = (pServerDynamicChannelContext*)ptr;
183 if (!c)
184 return;
185
186 if (c->backTracker.currentPacket)
187 Stream_Free(c->backTracker.currentPacket, TRUE);
188
189 if (c->frontTracker.currentPacket)
190 Stream_Free(c->frontTracker.currentPacket, TRUE);
191
192 if (c->channelDataDtor)
193 c->channelDataDtor(&c->channelData);
194
195 free(c->channelName);
196 free(c);
197}
198
199WINPR_ATTR_MALLOC(DynamicChannelContext_free, 1)
200WINPR_ATTR_NODISCARD
201static pServerDynamicChannelContext* DynamicChannelContext_new(wLog* log, pServerContext* ps,
202 const char* name, UINT32 id)
203{
204 WINPR_ASSERT(log);
205
206 pServerDynamicChannelContext* ret = calloc(1, sizeof(*ret));
207 if (!ret)
208 {
209 WLog_Print(log, WLOG_ERROR, "error allocating dynamic channel context '%s'", name);
210 return nullptr;
211 }
212
213 ret->channelId = id;
214 ret->channelName = _strdup(name);
215 if (!ret->channelName)
216 {
217 WLog_Print(log, WLOG_ERROR, "error allocating name in dynamic channel context '%s'", name);
218 free(ret);
219 return nullptr;
220 }
221
222 ret->frontTracker.dataCallback = data_cb;
223 ret->backTracker.dataCallback = data_cb;
224
225 proxyChannelToInterceptData dyn = { .name = name, .channelId = id, .intercept = FALSE };
226 if (pf_modules_run_filter(ps->pdata->module, FILTER_TYPE_DYN_INTERCEPT_LIST, ps->pdata, &dyn) &&
227 dyn.intercept)
228 ret->channelMode = PF_UTILS_CHANNEL_INTERCEPT;
229 else
230 ret->channelMode = pf_utils_get_channel_mode(ps->pdata->config, name);
231 ret->openStatus = CHANNEL_OPENSTATE_OPENED;
232 ret->packetReassembly = (ret->channelMode == PF_UTILS_CHANNEL_INTERCEPT);
233
234 return ret;
235}
236
237WINPR_ATTR_NODISCARD
238static UINT32 ChannelId_Hash(const void* key)
239{
240 const UINT32* v = (const UINT32*)key;
241 return *v;
242}
243
244WINPR_ATTR_NODISCARD
245static BOOL ChannelId_Compare(const void* objA, const void* objB)
246{
247 const UINT32* v1 = objA;
248 const UINT32* v2 = objB;
249 return (*v1 == *v2);
250}
251
252WINPR_ATTR_NODISCARD
253static DynvcReadResult dynvc_read_varInt(wLog* log, wStream* s, size_t len, UINT64* varInt,
254 BOOL last)
255{
256 WINPR_ASSERT(varInt);
257 switch (len)
258 {
259 case 0x00:
260 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 1))
261 return last ? DYNCVC_READ_ERROR : DYNCVC_READ_INCOMPLETE;
262 Stream_Read_UINT8(s, *varInt);
263 break;
264 case 0x01:
265 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 2))
266 return last ? DYNCVC_READ_ERROR : DYNCVC_READ_INCOMPLETE;
267 Stream_Read_UINT16(s, *varInt);
268 break;
269 case 0x02:
270 if (!Stream_CheckAndLogRequiredLengthWLog(log, s, 4))
271 return last ? DYNCVC_READ_ERROR : DYNCVC_READ_INCOMPLETE;
272 Stream_Read_UINT32(s, *varInt);
273 break;
274 case 0x03:
275 default:
276 WLog_Print(log, WLOG_ERROR, "Unknown int len %" PRIuz, len);
277 return DYNCVC_READ_ERROR;
278 }
279 return DYNCVC_READ_OK;
280}
281
282WINPR_ATTR_NODISCARD
283static PfChannelResult DynvcTrackerPeekHandleByMode(ChannelStateTracker* tracker,
284 DynChannelTrackerState* trackerState,
285 pServerDynamicChannelContext* dynChannel,
286 BYTE cmd, BOOL firstPacket, BOOL lastPacket)
287{
288 WINPR_ASSERT(tracker);
289 WINPR_ASSERT(trackerState);
290 WINPR_ASSERT(dynChannel);
291 PfChannelResult result = PF_CHANNEL_RESULT_ERROR;
292
293 DynChannelContext* dynChannelContext =
294 (DynChannelContext*)channelTracker_getCustomData(tracker);
295 WINPR_ASSERT(dynChannelContext);
296
297 proxyData* pdata = channelTracker_getPData(tracker);
298 WINPR_ASSERT(pdata);
299
300 const BOOL isBackData = (tracker == dynChannelContext->backTracker);
301 switch (dynChannel->channelMode)
302 {
303 case PF_UTILS_CHANNEL_PASSTHROUGH:
304 result = channelTracker_flushCurrent(tracker, firstPacket, lastPacket, !isBackData);
305 break;
306 case PF_UTILS_CHANNEL_BLOCK:
307 channelTracker_setMode(tracker, CHANNEL_TRACKER_DROP);
308 result = PF_CHANNEL_RESULT_DROP;
309 break;
310 case PF_UTILS_CHANNEL_INTERCEPT:
311 if (trackerState->dataCallback)
312 {
313 pServerContext* ps = proxy_data_get_server_context(pdata);
314 result = trackerState->dataCallback(ps, dynChannel, isBackData, tracker,
315 firstPacket, lastPacket);
316 }
317 else
318 {
319 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
320 "no intercept callback for channel, dropping packet");
321 result = PF_CHANNEL_RESULT_DROP;
322 }
323 break;
324 default:
325 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
326 "unknown channel mode %u", dynChannel->channelMode);
327 result = PF_CHANNEL_RESULT_ERROR;
328 break;
329 }
330
331 if (!trackerState->currentDataLength ||
332 (trackerState->CurrentDataReceived == trackerState->currentDataLength))
333 {
334 trackerState->currentDataLength = 0;
335 trackerState->CurrentDataFragments = 0;
336 trackerState->CurrentDataReceived = 0;
337
338 if (dynChannel->packetReassembly && trackerState->currentPacket)
339 Stream_ResetPosition(trackerState->currentPacket);
340 }
341
342 return result;
343}
344
345WINPR_ATTR_NODISCARD
346static PfChannelResult DynvcTrackerHandleClose(ChannelStateTracker* tracker,
347 pServerDynamicChannelContext* dynChannel,
348 DynChannelContext* dynChannelContext,
349 BOOL firstPacket, BOOL lastPacket)
350{
351 WINPR_ASSERT(dynChannelContext);
352
353 const BOOL isBackData = (tracker == dynChannelContext->backTracker);
354
355 if (!lastPacket || !dynChannel)
356 return PF_CHANNEL_RESULT_DROP;
357
358 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, CLOSE_REQUEST_PDU, isBackData,
359 "Close request");
360 channelTracker_setMode(tracker, CHANNEL_TRACKER_PASS);
361 if (dynChannel->openStatus != CHANNEL_OPENSTATE_OPENED)
362 {
363 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, CLOSE_REQUEST_PDU,
364 isBackData, "is in state %s, expected %s",
365 openstatus2str(dynChannel->openStatus),
366 openstatus2str(CHANNEL_OPENSTATE_OPENED));
367 }
368 dynChannel->openStatus = CHANNEL_OPENSTATE_CLOSED;
369 return channelTracker_flushCurrent(tracker, firstPacket, lastPacket, !isBackData);
370}
371
372WINPR_ATTR_NODISCARD
373static PfChannelResult DynvcTrackerHandleCreateBack(ChannelStateTracker* tracker, wStream* s,
374 DWORD flags, proxyData* pdata,
375 pServerDynamicChannelContext* dynChannel,
376 DynChannelContext* dynChannelContext,
377 UINT64 dynChannelId)
378{
379 proxyChannelDataEventInfo dev = WINPR_C_ARRAY_INIT;
380 const char* name = Stream_ConstPointer(s);
381 const size_t nameLen = Stream_GetRemainingLength(s);
382 const size_t len = strnlen(name, nameLen);
383 const BOOL isBackData = (tracker == dynChannelContext->backTracker);
384 const BYTE cmd = CREATE_REQUEST_PDU;
385
386 if ((len == 0) || (len == nameLen) || (dynChannelId > UINT16_MAX))
387 {
388 char namebuffer[64] = WINPR_C_ARRAY_INIT;
389 (void)_snprintf(namebuffer, sizeof(namebuffer) - 1, "%s", name);
390
391 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
392 "channel id %" PRIu64 ", name=%s [%" PRIuz "|%" PRIuz "], status=%s",
393 dynChannelId, namebuffer, len, nameLen,
394 dynChannel ? openstatus2str(dynChannel->openStatus) : "nullptr");
395 return PF_CHANNEL_RESULT_ERROR;
396 }
397
398 wStream* currentPacket = channelTracker_getCurrentPacket(tracker);
399 dev.channel_id = (UINT16)dynChannelId;
400 dev.channel_name = name;
401 dev.data = Stream_Buffer(s);
402 dev.data_len = Stream_GetPosition(currentPacket);
403 dev.flags = flags;
404 dev.total_size = Stream_GetPosition(currentPacket);
405
406 if (dynChannel)
407 {
408 DynvcTrackerLog(dynChannelContext->log, WLOG_WARN, dynChannel, cmd, isBackData,
409 "Reusing channel id, now %s", name);
410
411 HashTable_Remove(dynChannelContext->channels, &dynChannel->channelId);
412 }
413
414 if (!pf_modules_run_filter(pdata->module, FILTER_TYPE_CLIENT_PASSTHROUGH_DYN_CHANNEL_CREATE,
415 pdata, &dev))
416 return PF_CHANNEL_RESULT_DROP; /* Silently drop */
417
418 pServerContext* ps = proxy_data_get_server_context(pdata);
419 dynChannel = DynamicChannelContext_new(dynChannelContext->log, ps, name, (UINT32)dynChannelId);
420 if (!dynChannel)
421 {
422 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
423 "unable to create dynamic channel context data");
424 return PF_CHANNEL_RESULT_ERROR;
425 }
426
427 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, cmd, isBackData,
428 "Adding channel");
429 if (!HashTable_Insert(dynChannelContext->channels, &dynChannel->channelId, dynChannel))
430 {
431 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
432 "unable register dynamic channel context data");
433 DynamicChannelContext_free(dynChannel);
434 return PF_CHANNEL_RESULT_ERROR;
435 }
436
437 dynChannel->openStatus = CHANNEL_OPENSTATE_WAITING_OPEN_STATUS;
438
439 const BOOL firstPacket = (flags & CHANNEL_FLAG_FIRST) != 0;
440 const BOOL lastPacket = (flags & CHANNEL_FLAG_LAST) != 0;
441
442 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): HashTable_Insert owns dynChannel
443 return channelTracker_flushCurrent(tracker, firstPacket, lastPacket, FALSE);
444}
445
446WINPR_ATTR_NODISCARD
447static PfChannelResult DynvcTrackerHandleCreateFront(ChannelStateTracker* tracker, wStream* s,
448 DWORD flags,
449 WINPR_ATTR_UNUSED proxyData* pdata,
450 pServerDynamicChannelContext* dynChannel,
451 DynChannelContext* dynChannelContext,
452 WINPR_ATTR_UNUSED UINT64 dynChannelId)
453{
454 const BOOL isBackData = (tracker == dynChannelContext->backTracker);
455 const BYTE cmd = CREATE_REQUEST_PDU;
456
457 /* CREATE_REQUEST_PDU response */
458 if (!Stream_CheckAndLogRequiredLengthWLogWithBackend(dynChannelContext->log, s, 4, FALSE))
459 return PF_CHANNEL_RESULT_ERROR;
460
461 const UINT32 creationStatus = Stream_Get_UINT32(s);
462 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, cmd, isBackData,
463 "CREATE_RESPONSE openStatus=%" PRIu32, creationStatus);
464
465 if (dynChannel && (creationStatus == 0))
466 dynChannel->openStatus = CHANNEL_OPENSTATE_OPENED;
467
468 const BOOL firstPacket = (flags & CHANNEL_FLAG_FIRST) != 0;
469 const BOOL lastPacket = (flags & CHANNEL_FLAG_LAST) != 0;
470
471 return channelTracker_flushCurrent(tracker, firstPacket, lastPacket, TRUE);
472}
473
474WINPR_ATTR_NODISCARD
475static PfChannelResult DynvcTrackerHandleCreate(ChannelStateTracker* tracker, wStream* s,
476 DWORD flags,
477 pServerDynamicChannelContext* dynChannel,
478 UINT64 dynChannelId)
479{
480 WINPR_ASSERT(tracker);
481 WINPR_ASSERT(s);
482
483 DynChannelContext* dynChannelContext =
484 (DynChannelContext*)channelTracker_getCustomData(tracker);
485 WINPR_ASSERT(dynChannelContext);
486
487 const BOOL lastPacket = (flags & CHANNEL_FLAG_LAST) != 0;
488 const BOOL isBackData = (tracker == dynChannelContext->backTracker);
489
490 proxyData* pdata = channelTracker_getPData(tracker);
491 WINPR_ASSERT(pdata);
492
493 /* we only want the full packet */
494 if (!lastPacket)
495 return PF_CHANNEL_RESULT_DROP;
496
497 if (isBackData)
498 return DynvcTrackerHandleCreateBack(tracker, s, flags, pdata, dynChannel, dynChannelContext,
499 dynChannelId);
500
501 return DynvcTrackerHandleCreateFront(tracker, s, flags, pdata, dynChannel, dynChannelContext,
502 dynChannelId);
503}
504
505WINPR_ATTR_NODISCARD
506static PfChannelResult DynvcTrackerHandleCmdDATA(ChannelStateTracker* tracker,
507 pServerDynamicChannelContext* dynChannel,
508 wStream* s, BYTE cmd, UINT64 Length,
509 BOOL firstPacket, BOOL lastPacket)
510{
511 WINPR_ASSERT(tracker);
512 WINPR_ASSERT(s);
513
514 DynChannelContext* dynChannelContext =
515 (DynChannelContext*)channelTracker_getCustomData(tracker);
516 WINPR_ASSERT(dynChannelContext);
517
518 const BOOL isBackData = (tracker == dynChannelContext->backTracker);
519
520 if (!dynChannel)
521 {
522 DynvcTrackerLog(dynChannelContext->log, WLOG_WARN, dynChannel, cmd, isBackData,
523 "channel is nullptr, dropping packet");
524 return PF_CHANNEL_RESULT_DROP;
525 }
526
527 DynChannelTrackerState* trackerState =
528 isBackData ? &dynChannel->backTracker : &dynChannel->frontTracker;
529 if (dynChannel->openStatus != CHANNEL_OPENSTATE_OPENED)
530 {
531 DynvcTrackerLog(dynChannelContext->log, WLOG_WARN, dynChannel, cmd, isBackData,
532 "channel is not opened, dropping packet");
533 return PF_CHANNEL_RESULT_DROP;
534 }
535
536 switch (cmd)
537 {
538 case DATA_FIRST_PDU:
539 case DATA_FIRST_COMPRESSED_PDU:
540 {
541 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, cmd, isBackData,
542 "DATA_FIRST currentPacketLength=%" PRIu64 "", Length);
543 if (Length > UINT32_MAX)
544 {
545 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
546 "Length out of bounds: %" PRIu64, Length);
547 return PF_CHANNEL_RESULT_ERROR;
548 }
549 trackerState->currentDataLength = (UINT32)Length;
550 trackerState->CurrentDataReceived = 0;
551 trackerState->CurrentDataFragments = 0;
552
553 if (dynChannel->packetReassembly)
554 {
555 if (trackerState->currentPacket)
556 Stream_ResetPosition(trackerState->currentPacket);
557 }
558 }
559 break;
560 default:
561 break;
562 }
563
564 switch (cmd)
565 {
566 case DATA_PDU:
567 case DATA_FIRST_PDU:
568 {
569 size_t extraSize = Stream_GetRemainingLength(s);
570
571 trackerState->CurrentDataFragments++;
572 trackerState->CurrentDataReceived += WINPR_ASSERTING_INT_CAST(uint32_t, extraSize);
573
574 if (dynChannel->packetReassembly)
575 {
576 if (!trackerState->currentPacket)
577 {
578 trackerState->currentPacket = Stream_New(nullptr, 1024);
579 if (!trackerState->currentPacket)
580 {
581 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd,
582 isBackData, "unable to create current packet",
583 getDirection(isBackData), dynChannel->channelName,
584 drdynvc_get_packet_type(cmd));
585 return PF_CHANNEL_RESULT_ERROR;
586 }
587 }
588
589 if (!Stream_EnsureRemainingCapacity(trackerState->currentPacket, extraSize))
590 {
591 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
592 "unable to grow current packet", getDirection(isBackData),
593 dynChannel->channelName, drdynvc_get_packet_type(cmd));
594 return PF_CHANNEL_RESULT_ERROR;
595 }
596
597 Stream_Write(trackerState->currentPacket, Stream_ConstPointer(s), extraSize);
598 }
599 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, cmd, isBackData,
600 "frags=%" PRIu32 " received=%" PRIu32 "(%" PRIu32 ")",
601 trackerState->CurrentDataFragments, trackerState->CurrentDataReceived,
602 trackerState->currentDataLength);
603 }
604 break;
605 default:
606 break;
607 }
608
609 switch (cmd)
610 {
611 case DATA_PDU:
612 {
613 if (trackerState->currentDataLength)
614 {
615 if (trackerState->CurrentDataReceived > trackerState->currentDataLength)
616 {
617 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
618 "reassembled packet (%" PRIu32
619 ") is bigger than announced length (%" PRIu32 ")",
620 trackerState->CurrentDataReceived,
621 trackerState->currentDataLength);
622 return PF_CHANNEL_RESULT_ERROR;
623 }
624 }
625 else
626 {
627 trackerState->CurrentDataFragments = 0;
628 trackerState->CurrentDataReceived = 0;
629 }
630 }
631 break;
632 default:
633 break;
634 }
635
636 return DynvcTrackerPeekHandleByMode(tracker, trackerState, dynChannel, cmd, firstPacket,
637 lastPacket);
638}
639
640WINPR_ATTR_NODISCARD
641static PfChannelResult DynvcTrackerHandleCmd(ChannelStateTracker* tracker,
642 pServerDynamicChannelContext* dynChannel, wStream* s,
643 BYTE cmd, UINT32 flags, UINT64 Length,
644 UINT64 dynChannelId, BOOL firstPacket, BOOL lastPacket)
645{
646 WINPR_ASSERT(tracker);
647 WINPR_ASSERT(s);
648
649 DynChannelContext* dynChannelContext =
650 (DynChannelContext*)channelTracker_getCustomData(tracker);
651 WINPR_ASSERT(dynChannelContext);
652
653 const BOOL isBackData = (tracker == dynChannelContext->backTracker);
654 switch (cmd)
655 {
656 case CAPABILITY_REQUEST_PDU:
657 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, cmd, isBackData,
658 "CAPABILITY_%s", isBackData ? "REQUEST" : "RESPONSE");
659 channelTracker_setMode(tracker, CHANNEL_TRACKER_PASS);
660 return PF_CHANNEL_RESULT_PASS;
661
662 case CREATE_REQUEST_PDU:
663 return DynvcTrackerHandleCreate(tracker, s, flags, dynChannel, dynChannelId);
664
665 case CLOSE_REQUEST_PDU:
666 return DynvcTrackerHandleClose(tracker, dynChannel, dynChannelContext, firstPacket,
667 lastPacket);
668
669 case SOFT_SYNC_REQUEST_PDU:
670 /* just pass then as is for now */
671 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, cmd, isBackData,
672 "SOFT_SYNC_REQUEST_PDU");
673 channelTracker_setMode(tracker, CHANNEL_TRACKER_PASS);
674 /*TODO: return pf_treat_softsync_req(pdata, s);*/
675 return PF_CHANNEL_RESULT_PASS;
676
677 case SOFT_SYNC_RESPONSE_PDU:
678 /* just pass then as is for now */
679 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, cmd, isBackData,
680 "SOFT_SYNC_RESPONSE_PDU");
681 channelTracker_setMode(tracker, CHANNEL_TRACKER_PASS);
682 return PF_CHANNEL_RESULT_PASS;
683
684 case DATA_FIRST_PDU:
685 case DATA_PDU:
686 return DynvcTrackerHandleCmdDATA(tracker, dynChannel, s, cmd, Length, firstPacket,
687 lastPacket);
688
689 case DATA_FIRST_COMPRESSED_PDU:
690 case DATA_COMPRESSED_PDU:
691 DynvcTrackerLog(dynChannelContext->log, WLOG_DEBUG, dynChannel, cmd, isBackData,
692 "TODO: compressed data packets, pass them as is for now");
693 channelTracker_setMode(tracker, CHANNEL_TRACKER_PASS);
694 return channelTracker_flushCurrent(tracker, firstPacket, lastPacket, !isBackData);
695
696 default:
697 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
698 "Invalid command ID");
699 return PF_CHANNEL_RESULT_ERROR;
700 }
701}
702
703WINPR_ATTR_NODISCARD
704static PfChannelResult DynvcTrackerPeekFn(ChannelStateTracker* tracker, BOOL firstPacket,
705 BOOL lastPacket)
706{
707 wStream* s = nullptr;
708 wStream sbuffer;
709 BOOL haveChannelId = 0;
710 BOOL haveLength = 0;
711 UINT64 dynChannelId = 0;
712 UINT64 Length = 0;
713 pServerDynamicChannelContext* dynChannel = nullptr;
714
715 WINPR_ASSERT(tracker);
716
717 DynChannelContext* dynChannelContext =
718 (DynChannelContext*)channelTracker_getCustomData(tracker);
719 WINPR_ASSERT(dynChannelContext);
720
721 const BOOL isBackData = (tracker == dynChannelContext->backTracker);
722
723 UINT32 flags = lastPacket ? CHANNEL_FLAG_LAST : 0;
724 if (firstPacket)
725 flags |= CHANNEL_FLAG_FIRST;
726
727 {
728 wStream* currentPacket = channelTracker_getCurrentPacket(tracker);
729 s = Stream_StaticConstInit(&sbuffer, Stream_Buffer(currentPacket),
730 Stream_GetPosition(currentPacket));
731 }
732
733 if (!Stream_CheckAndLogRequiredLengthWLogWithBackend(dynChannelContext->log, s, 1, isBackData))
734 return PF_CHANNEL_RESULT_ERROR;
735
736 const BYTE byte0 = Stream_Get_UINT8(s);
737 const BYTE cmd = byte0 >> 4;
738
739 switch (cmd)
740 {
741 case CREATE_REQUEST_PDU:
742 case CLOSE_REQUEST_PDU:
743 case DATA_PDU:
744 case DATA_COMPRESSED_PDU:
745 haveChannelId = TRUE;
746 haveLength = FALSE;
747 break;
748 case DATA_FIRST_PDU:
749 case DATA_FIRST_COMPRESSED_PDU:
750 haveLength = TRUE;
751 haveChannelId = TRUE;
752 break;
753 default:
754 haveChannelId = FALSE;
755 haveLength = FALSE;
756 break;
757 }
758
759 if (haveChannelId)
760 {
761 BYTE cbId = byte0 & 0x03;
762
763 switch (dynvc_read_varInt(dynChannelContext->log, s, cbId, &dynChannelId, lastPacket))
764 {
765 case DYNCVC_READ_OK:
766 break;
767 case DYNCVC_READ_INCOMPLETE:
768 return PF_CHANNEL_RESULT_DROP;
769 case DYNCVC_READ_ERROR:
770 default:
771 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
772 "invalid channelId field");
773 return PF_CHANNEL_RESULT_ERROR;
774 }
775
776 /* we always try to retrieve the dynamic channel in case it would have been opened
777 * and closed
778 */
779 dynChannel = (pServerDynamicChannelContext*)HashTable_GetItemValue(
780 dynChannelContext->channels, &dynChannelId);
781 if ((cmd != CREATE_REQUEST_PDU) || !isBackData)
782 {
783 if (!dynChannel || (dynChannel->openStatus == CHANNEL_OPENSTATE_CLOSED))
784 {
785 /* we've not found the target channel, so we drop this chunk, plus all the rest of
786 * the packet */
787 channelTracker_setMode(tracker, CHANNEL_TRACKER_DROP);
788 return PF_CHANNEL_RESULT_DROP;
789 }
790 }
791 }
792
793 if (haveLength)
794 {
795 BYTE lenLen = (byte0 >> 2) & 0x03;
796 switch (dynvc_read_varInt(dynChannelContext->log, s, lenLen, &Length, lastPacket))
797 {
798 case DYNCVC_READ_OK:
799 break;
800 case DYNCVC_READ_INCOMPLETE:
801 return PF_CHANNEL_RESULT_DROP;
802 case DYNCVC_READ_ERROR:
803 default:
804 DynvcTrackerLog(dynChannelContext->log, WLOG_ERROR, dynChannel, cmd, isBackData,
805 "invalid length field");
806 return PF_CHANNEL_RESULT_ERROR;
807 }
808 }
809
810 return DynvcTrackerHandleCmd(tracker, dynChannel, s, cmd, flags, Length, dynChannelId,
811 firstPacket, lastPacket);
812}
813
814static void DynChannelContext_free(void* context)
815{
816 DynChannelContext* c = context;
817 if (!c)
818 return;
819 channelTracker_free(c->backTracker);
820 channelTracker_free(c->frontTracker);
821 HashTable_Free(c->channels);
822 WLog_Discard(c->log);
823 free(c);
824}
825
826WINPR_ATTR_NODISCARD
827static const char* dynamic_context(void* arg)
828{
829 proxyData* pdata = arg;
830 if (!pdata)
831 return "pdata=null";
832 return pdata->session_id;
833}
834
835WINPR_ATTR_MALLOC(DynChannelContext_free, 1)
836static DynChannelContext* DynChannelContext_new(proxyData* pdata,
837 pServerStaticChannelContext* channel)
838{
839 DynChannelContext* dyn = calloc(1, sizeof(DynChannelContext));
840 if (!dyn)
841 return nullptr;
842
843 dyn->log = WLog_Create(DTAG, WLog_GetRoot());
844 if (!dyn->log)
845 goto fail;
846
847 if (!WLog_SetContext(dyn->log, dynamic_context, pdata))
848 goto fail;
849
850 dyn->backTracker = channelTracker_new(channel, DynvcTrackerPeekFn, dyn);
851 if (!dyn->backTracker)
852 goto fail;
853 if (!channelTracker_setPData(dyn->backTracker, pdata))
854 goto fail;
855
856 dyn->frontTracker = channelTracker_new(channel, DynvcTrackerPeekFn, dyn);
857 if (!dyn->frontTracker)
858 goto fail;
859 if (!channelTracker_setPData(dyn->frontTracker, pdata))
860 goto fail;
861
862 dyn->channels = HashTable_New(FALSE);
863 if (!dyn->channels)
864 goto fail;
865
866 if (!HashTable_SetHashFunction(dyn->channels, ChannelId_Hash))
867 goto fail;
868
869 {
870 wObject* kobj = HashTable_KeyObject(dyn->channels);
871 WINPR_ASSERT(kobj);
872 kobj->fnObjectEquals = ChannelId_Compare;
873 }
874
875 {
876 wObject* vobj = HashTable_ValueObject(dyn->channels);
877 WINPR_ASSERT(vobj);
878 vobj->fnObjectFree = DynamicChannelContext_free;
879 }
880
881 return dyn;
882
883fail:
884 DynChannelContext_free(dyn);
885 return nullptr;
886}
887
888WINPR_ATTR_NODISCARD
889static PfChannelResult pf_dynvc_back_data(proxyData* pdata,
890 const pServerStaticChannelContext* channel,
891 const BYTE* xdata, size_t xsize, UINT32 flags,
892 size_t totalSize)
893{
894 WINPR_ASSERT(channel);
895
896 DynChannelContext* dyn = (DynChannelContext*)channel->context;
897 WINPR_UNUSED(pdata);
898 WINPR_ASSERT(dyn);
899
900 return channelTracker_update(dyn->backTracker, xdata, xsize, flags, totalSize);
901}
902
903WINPR_ATTR_NODISCARD
904static PfChannelResult pf_dynvc_front_data(proxyData* pdata,
905 const pServerStaticChannelContext* channel,
906 const BYTE* xdata, size_t xsize, UINT32 flags,
907 size_t totalSize)
908{
909 WINPR_ASSERT(channel);
910
911 DynChannelContext* dyn = (DynChannelContext*)channel->context;
912 WINPR_UNUSED(pdata);
913 WINPR_ASSERT(dyn);
914
915 return channelTracker_update(dyn->frontTracker, xdata, xsize, flags, totalSize);
916}
917
918BOOL pf_channel_setup_drdynvc(proxyData* pdata, pServerStaticChannelContext* channel)
919{
920 DynChannelContext* ret = DynChannelContext_new(pdata, channel);
921 if (!ret)
922 return FALSE;
923
924 channel->onBackData = pf_dynvc_back_data;
925 channel->onFrontData = pf_dynvc_front_data;
926 channel->contextDtor = DynChannelContext_free;
927 channel->context = ret;
928 return TRUE;
929}
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59
wObject::fnObjectEquals
WINPR_ATTR_NODISCARD OBJECT_EQUALS_FN fnObjectEquals
Definition collections.h:61