FreeRDP
Loading...
Searching...
No Matches
rts.c
1
20#include <freerdp/config.h>
21
22#include <winpr/assert.h>
23#include <winpr/cast.h>
24#include <winpr/crt.h>
25#include <winpr/crypto.h>
26
27#include <freerdp/log.h>
28
29#include "ncacn_http.h"
30#include "rpc_client.h"
31#include "rts_signature.h"
32
33#include "rts.h"
34
35#define TAG FREERDP_TAG("core.gateway.rts")
36
70static int rts_destination_command_read(rdpRpc* rpc, wStream* buffer, UINT32* Destination);
71
72static const char* rts_command_to_string(UINT32 cmd, char* buffer, size_t len)
73{
74 const char* str = nullptr;
75
76#undef ENTRY
77#define ENTRY(x) \
78 case x: \
79 str = "#x"; \
80 break
81
82 switch (cmd)
83 {
84 ENTRY(RTS_CMD_RECEIVE_WINDOW_SIZE);
85 ENTRY(RTS_CMD_FLOW_CONTROL_ACK);
86 ENTRY(RTS_CMD_CONNECTION_TIMEOUT);
87 ENTRY(RTS_CMD_COOKIE);
88 ENTRY(RTS_CMD_CHANNEL_LIFETIME);
89 ENTRY(RTS_CMD_CLIENT_KEEPALIVE);
90 ENTRY(RTS_CMD_VERSION);
91 ENTRY(RTS_CMD_EMPTY);
92 ENTRY(RTS_CMD_PADDING);
93 ENTRY(RTS_CMD_NEGATIVE_ANCE);
94 ENTRY(RTS_CMD_ANCE);
95 ENTRY(RTS_CMD_CLIENT_ADDRESS);
96 ENTRY(RTS_CMD_ASSOCIATION_GROUP_ID);
97 ENTRY(RTS_CMD_DESTINATION);
98 ENTRY(RTS_CMD_PING_TRAFFIC_SENT_NOTIFY);
99 ENTRY(RTS_CMD_LAST_ID);
100 default:
101 str = "RTS_CMD_UNKNOWN";
102 break;
103 }
104
105#undef ENTRY
106
107 (void)_snprintf(buffer, len, "%s [0x%08" PRIx32 "]", str, cmd);
108 return buffer;
109}
110
111static const char* rts_pdu_ptype_to_string(UINT32 ptype)
112{
113 switch (ptype)
114 {
115 case PTYPE_REQUEST:
116 return "PTYPE_REQUEST";
117 case PTYPE_PING:
118 return "PTYPE_PING";
119 case PTYPE_RESPONSE:
120 return "PTYPE_RESPONSE";
121 case PTYPE_FAULT:
122 return "PTYPE_FAULT";
123 case PTYPE_WORKING:
124 return "PTYPE_WORKING";
125 case PTYPE_NOCALL:
126 return "PTYPE_NOCALL";
127 case PTYPE_REJECT:
128 return "PTYPE_REJECT";
129 case PTYPE_ACK:
130 return "PTYPE_ACK";
131 case PTYPE_CL_CANCEL:
132 return "PTYPE_CL_CANCEL";
133 case PTYPE_FACK:
134 return "PTYPE_FACK";
135 case PTYPE_CANCEL_ACK:
136 return "PTYPE_CANCEL_ACK";
137 case PTYPE_BIND:
138 return "PTYPE_BIND";
139 case PTYPE_BIND_ACK:
140 return "PTYPE_BIND_ACK";
141 case PTYPE_BIND_NAK:
142 return "PTYPE_BIND_NAK";
143 case PTYPE_ALTER_CONTEXT:
144 return "PTYPE_ALTER_CONTEXT";
145 case PTYPE_ALTER_CONTEXT_RESP:
146 return "PTYPE_ALTER_CONTEXT_RESP";
147 case PTYPE_RPC_AUTH_3:
148 return "PTYPE_RPC_AUTH_3";
149 case PTYPE_SHUTDOWN:
150 return "PTYPE_SHUTDOWN";
151 case PTYPE_CO_CANCEL:
152 return "PTYPE_CO_CANCEL";
153 case PTYPE_ORPHANED:
154 return "PTYPE_ORPHANED";
155 case PTYPE_RTS:
156 return "PTYPE_RTS";
157 default:
158 return "UNKNOWN";
159 }
160}
161
162static rpcconn_rts_hdr_t rts_pdu_header_init(void)
163{
164 rpcconn_rts_hdr_t header = WINPR_C_ARRAY_INIT;
165 header.header.rpc_vers = 5;
166 header.header.rpc_vers_minor = 0;
167 header.header.ptype = PTYPE_RTS;
168 header.header.packed_drep[0] = 0x10;
169 header.header.packed_drep[1] = 0x00;
170 header.header.packed_drep[2] = 0x00;
171 header.header.packed_drep[3] = 0x00;
172 header.header.pfc_flags = PFC_FIRST_FRAG | PFC_LAST_FRAG;
173 header.header.auth_length = 0;
174 header.header.call_id = 0;
175
176 return header;
177}
178
179static BOOL rts_align_stream(wStream* s, size_t alignment, BOOL silent)
180{
181 size_t pos = 0;
182 size_t pad = 0;
183
184 WINPR_ASSERT(s);
185 WINPR_ASSERT(alignment > 0);
186
187 pos = Stream_GetPosition(s);
188 pad = rpc_offset_align(&pos, alignment);
189 return Stream_ConditionalSafeSeek(s, pad, silent);
190}
191
192static char* sdup(const void* src, size_t length)
193{
194 char* dst = nullptr;
195 WINPR_ASSERT(src || (length == 0));
196 if (length == 0)
197 return nullptr;
198
199 dst = calloc(length + 1, sizeof(char));
200 if (!dst)
201 return nullptr;
202 memcpy(dst, src, length);
203 return dst;
204}
205
206static BOOL rts_write_common_pdu_header(wStream* s, const rpcconn_common_hdr_t* header)
207{
208 WINPR_ASSERT(s);
209 WINPR_ASSERT(header);
210 if (!Stream_EnsureRemainingCapacity(s, sizeof(rpcconn_common_hdr_t)))
211 return FALSE;
212
213 Stream_Write_UINT8(s, header->rpc_vers);
214 Stream_Write_UINT8(s, header->rpc_vers_minor);
215 Stream_Write_UINT8(s, header->ptype);
216 Stream_Write_UINT8(s, header->pfc_flags);
217 Stream_Write(s, header->packed_drep, ARRAYSIZE(header->packed_drep));
218 Stream_Write_UINT16(s, header->frag_length);
219 Stream_Write_UINT16(s, header->auth_length);
220 Stream_Write_UINT32(s, header->call_id);
221 return TRUE;
222}
223
224rts_pdu_status_t rts_read_common_pdu_header(wStream* s, rpcconn_common_hdr_t* header,
225 BOOL ignoreErrors)
226{
227 WINPR_ASSERT(s);
228 WINPR_ASSERT(header);
229
230 if (!ignoreErrors)
231 {
232 if (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(rpcconn_common_hdr_t)))
233 return RTS_PDU_INCOMPLETE;
234 }
235 else
236 {
237 const size_t sz = Stream_GetRemainingLength(s);
238 if (sz < sizeof(rpcconn_common_hdr_t))
239 return RTS_PDU_INCOMPLETE;
240 }
241
242 Stream_Read_UINT8(s, header->rpc_vers);
243 Stream_Read_UINT8(s, header->rpc_vers_minor);
244 Stream_Read_UINT8(s, header->ptype);
245 Stream_Read_UINT8(s, header->pfc_flags);
246 Stream_Read(s, header->packed_drep, ARRAYSIZE(header->packed_drep));
247 Stream_Read_UINT16(s, header->frag_length);
248 Stream_Read_UINT16(s, header->auth_length);
249 Stream_Read_UINT32(s, header->call_id);
250
251 if (header->frag_length < sizeof(rpcconn_common_hdr_t))
252 {
253 if (!ignoreErrors)
254 WLog_WARN(TAG, "Invalid header->frag_length of %" PRIu16 ", expected %" PRIuz,
255 header->frag_length, sizeof(rpcconn_common_hdr_t));
256 return RTS_PDU_FAIL;
257 }
258 if (header->auth_length > header->frag_length - 8ull)
259 {
260 if (!ignoreErrors)
261 WLog_WARN(TAG,
262 "Invalid header->auth_length(%" PRIu16 ") > header->frag_length(%" PRIu16
263 ") - 8ull",
264 header->frag_length, header->auth_length);
265 return RTS_PDU_FAIL;
266 }
267
268 if (!ignoreErrors)
269 {
270 if (!Stream_CheckAndLogRequiredLength(TAG, s,
271 header->frag_length - sizeof(rpcconn_common_hdr_t)))
272 return RTS_PDU_INCOMPLETE;
273 }
274 else
275 {
276 const size_t sz2 = Stream_GetRemainingLength(s);
277 if (sz2 < header->frag_length - sizeof(rpcconn_common_hdr_t))
278 return RTS_PDU_INCOMPLETE;
279 }
280 return RTS_PDU_VALID;
281}
282
283static BOOL rts_read_auth_verifier_no_checks(wStream* s, auth_verifier_co_t* auth,
284 const rpcconn_common_hdr_t* header, size_t* startPos,
285 BOOL silent)
286{
287 WINPR_ASSERT(s);
288 WINPR_ASSERT(auth);
289 WINPR_ASSERT(header);
290
291 WINPR_ASSERT(header->frag_length > header->auth_length + 8);
292
293 if (startPos)
294 *startPos = Stream_GetPosition(s);
295
296 /* Read the auth verifier and check padding matches frag_length */
297 {
298 const size_t expected = header->frag_length - header->auth_length - 8;
299
300 if (!Stream_SetPosition(s, expected))
301 return FALSE;
302 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 8, silent))
303 return FALSE;
304
305 Stream_Read_UINT8(s, auth->auth_type);
306 Stream_Read_UINT8(s, auth->auth_level);
307 Stream_Read_UINT8(s, auth->auth_pad_length);
308 Stream_Read_UINT8(s, auth->auth_reserved);
309 Stream_Read_UINT32(s, auth->auth_context_id);
310 }
311
312 if (header->auth_length != 0)
313 {
314 const void* ptr = Stream_Pointer(s);
315 if (!Stream_ConditionalSafeSeek(s, header->auth_length, silent))
316 return FALSE;
317 auth->auth_value = (BYTE*)sdup(ptr, header->auth_length);
318 if (auth->auth_value == nullptr)
319 return FALSE;
320 }
321
322 return TRUE;
323}
324
325static BOOL rts_read_auth_verifier(wStream* s, auth_verifier_co_t* auth,
326 const rpcconn_common_hdr_t* header, BOOL silent)
327{
328 size_t pos = 0;
329 WINPR_ASSERT(s);
330 WINPR_ASSERT(auth);
331 WINPR_ASSERT(header);
332
333 if (!rts_read_auth_verifier_no_checks(s, auth, header, &pos, silent))
334 return FALSE;
335
336 const size_t expected = header->frag_length - header->auth_length - 8;
337 WINPR_ASSERT(pos + auth->auth_pad_length == expected);
338 return pos + auth->auth_pad_length == expected;
339}
340
341static BOOL rts_read_auth_verifier_with_stub(wStream* s, auth_verifier_co_t* auth,
342 rpcconn_common_hdr_t* header, BOOL silent)
343{
344 size_t pos = 0;
345 size_t alloc_hint = 0;
346 BYTE** ptr = nullptr;
347
348 if (!rts_read_auth_verifier_no_checks(s, auth, header, &pos, silent))
349 return FALSE;
350
351 switch (header->ptype)
352 {
353 case PTYPE_FAULT:
354 {
355 rpcconn_fault_hdr_t* hdr = (rpcconn_fault_hdr_t*)header;
356 alloc_hint = hdr->alloc_hint;
357 ptr = &hdr->stub_data;
358 }
359 break;
360 case PTYPE_RESPONSE:
361 {
362 rpcconn_response_hdr_t* hdr = (rpcconn_response_hdr_t*)header;
363 alloc_hint = hdr->alloc_hint;
364 ptr = &hdr->stub_data;
365 }
366 break;
367 case PTYPE_REQUEST:
368 {
369 rpcconn_request_hdr_t* hdr = (rpcconn_request_hdr_t*)header;
370 alloc_hint = hdr->alloc_hint;
371 ptr = &hdr->stub_data;
372 }
373 break;
374 default:
375 return FALSE;
376 }
377
378 if (alloc_hint > 0)
379 {
380 const size_t off = header->auth_length + 8 + auth->auth_pad_length + pos;
381 const size_t size = header->frag_length - MIN(header->frag_length, off);
382 const void* src = Stream_Buffer(s) + pos;
383
384 if (off > header->frag_length)
385 WLog_WARN(TAG,
386 "Unexpected alloc_hint(%" PRIuz ") for PDU %s: size %" PRIuz
387 ", frag_length %" PRIu16 ", offset %" PRIuz,
388 alloc_hint, rts_pdu_ptype_to_string(header->ptype), size, header->frag_length,
389 off);
390
391 *ptr = nullptr;
392 if (size > 0)
393 {
394 *ptr = (BYTE*)sdup(src, size);
395 if (!*ptr)
396 return FALSE;
397 }
398 }
399
400 return TRUE;
401}
402
403static void rts_free_auth_verifier(auth_verifier_co_t* auth)
404{
405 if (!auth)
406 return;
407 free(auth->auth_value);
408}
409
410static BOOL rts_write_auth_verifier(wStream* s, const auth_verifier_co_t* auth,
411 const rpcconn_common_hdr_t* header)
412{
413 size_t pos = 0;
414 UINT8 auth_pad_length = 0;
415
416 WINPR_ASSERT(s);
417 WINPR_ASSERT(auth);
418 WINPR_ASSERT(header);
419
420 /* Align start to a multiple of 4 */
421 pos = Stream_GetPosition(s);
422 if ((pos % 4) != 0)
423 {
424 auth_pad_length = 4 - (pos % 4);
425 if (!Stream_EnsureRemainingCapacity(s, auth_pad_length))
426 return FALSE;
427 Stream_Zero(s, auth_pad_length);
428 }
429
430#if defined(WITH_VERBOSE_WINPR_ASSERT) && (WITH_VERBOSE_WINPR_ASSERT != 0)
431 WINPR_ASSERT(header->frag_length + 8ull > header->auth_length);
432 {
433 size_t apos = Stream_GetPosition(s);
434 size_t expected = header->frag_length - header->auth_length - 8;
435
436 WINPR_ASSERT(apos == expected);
437 }
438#endif
439
440 if (!Stream_EnsureRemainingCapacity(s, sizeof(auth_verifier_co_t)))
441 return FALSE;
442
443 Stream_Write_UINT8(s, auth->auth_type);
444 Stream_Write_UINT8(s, auth->auth_level);
445 Stream_Write_UINT8(s, auth_pad_length);
446 Stream_Write_UINT8(s, 0); /* auth->auth_reserved */
447 Stream_Write_UINT32(s, auth->auth_context_id);
448
449 if (!Stream_EnsureRemainingCapacity(s, header->auth_length))
450 return FALSE;
451 Stream_Write(s, auth->auth_value, header->auth_length);
452 return TRUE;
453}
454
455static BOOL rts_read_version(wStream* s, p_rt_version_t* version, BOOL silent)
456{
457 WINPR_ASSERT(s);
458 WINPR_ASSERT(version);
459
460 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 2 * sizeof(UINT8), silent))
461 return FALSE;
462 Stream_Read_UINT8(s, version->major);
463 Stream_Read_UINT8(s, version->minor);
464 return TRUE;
465}
466
467static void rts_free_supported_versions(p_rt_versions_supported_t* versions)
468{
469 if (!versions)
470 return;
471 free(versions->p_protocols);
472 versions->p_protocols = nullptr;
473}
474
475static BOOL rts_read_supported_versions(wStream* s, p_rt_versions_supported_t* versions,
476 BOOL silent)
477{
478 WINPR_ASSERT(s);
479 WINPR_ASSERT(versions);
480
481 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, sizeof(UINT8), silent))
482 return FALSE;
483
484 Stream_Read_UINT8(s, versions->n_protocols); /* count */
485
486 if (versions->n_protocols > 0)
487 {
488 versions->p_protocols = calloc(versions->n_protocols, sizeof(p_rt_version_t));
489 if (!versions->p_protocols)
490 return FALSE;
491 }
492 for (BYTE x = 0; x < versions->n_protocols; x++)
493 {
494 p_rt_version_t* version = &versions->p_protocols[x];
495 if (!rts_read_version(s, version, silent)) /* size_is(n_protocols) */
496 {
497 rts_free_supported_versions(versions);
498 return FALSE;
499 }
500 }
501
502 return TRUE;
503}
504
505static BOOL rts_read_port_any(wStream* s, port_any_t* port, BOOL silent)
506{
507 WINPR_ASSERT(s);
508 WINPR_ASSERT(port);
509
510 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, sizeof(UINT16), silent))
511 return FALSE;
512
513 Stream_Read_UINT16(s, port->length);
514 if (port->length == 0)
515 return TRUE;
516
517 const void* ptr = Stream_ConstPointer(s);
518 if (!Stream_ConditionalSafeSeek(s, port->length, silent))
519 return FALSE;
520 port->port_spec = sdup(ptr, port->length);
521 return port->port_spec != nullptr;
522}
523
524static void rts_free_port_any(port_any_t* port)
525{
526 if (!port)
527 return;
528 free(port->port_spec);
529}
530
531static BOOL rts_read_uuid(wStream* s, p_uuid_t* uuid, BOOL silent)
532{
533 WINPR_ASSERT(s);
534 WINPR_ASSERT(uuid);
535
536 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, sizeof(p_uuid_t), silent))
537 return FALSE;
538
539 Stream_Read_UINT32(s, uuid->time_low);
540 Stream_Read_UINT16(s, uuid->time_mid);
541 Stream_Read_UINT16(s, uuid->time_hi_and_version);
542 Stream_Read_UINT8(s, uuid->clock_seq_hi_and_reserved);
543 Stream_Read_UINT8(s, uuid->clock_seq_low);
544 Stream_Read(s, uuid->node, ARRAYSIZE(uuid->node));
545 return TRUE;
546}
547
548static BOOL rts_write_uuid(wStream* s, const p_uuid_t* uuid)
549{
550 WINPR_ASSERT(s);
551 WINPR_ASSERT(uuid);
552
553 if (!Stream_EnsureRemainingCapacity(s, sizeof(p_uuid_t)))
554 return FALSE;
555
556 Stream_Write_UINT32(s, uuid->time_low);
557 Stream_Write_UINT16(s, uuid->time_mid);
558 Stream_Write_UINT16(s, uuid->time_hi_and_version);
559 Stream_Write_UINT8(s, uuid->clock_seq_hi_and_reserved);
560 Stream_Write_UINT8(s, uuid->clock_seq_low);
561 Stream_Write(s, uuid->node, ARRAYSIZE(uuid->node));
562 return TRUE;
563}
564
565static p_syntax_id_t* rts_syntax_id_new(size_t count)
566{
567 return calloc(count, sizeof(p_syntax_id_t));
568}
569
570static void rts_syntax_id_free(p_syntax_id_t* ptr)
571{
572 free(ptr);
573}
574
575static BOOL rts_read_syntax_id(wStream* s, p_syntax_id_t* syntax_id, BOOL silent)
576{
577 WINPR_ASSERT(s);
578 WINPR_ASSERT(syntax_id);
579
580 if (!rts_read_uuid(s, &syntax_id->if_uuid, silent))
581 return FALSE;
582
583 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 4, silent))
584 return FALSE;
585
586 Stream_Read_UINT32(s, syntax_id->if_version);
587 return TRUE;
588}
589
590static BOOL rts_write_syntax_id(wStream* s, const p_syntax_id_t* syntax_id)
591{
592 WINPR_ASSERT(s);
593 WINPR_ASSERT(syntax_id);
594
595 if (!rts_write_uuid(s, &syntax_id->if_uuid))
596 return FALSE;
597
598 if (!Stream_EnsureRemainingCapacity(s, 4))
599 return FALSE;
600
601 Stream_Write_UINT32(s, syntax_id->if_version);
602 return TRUE;
603}
604
605static void rts_context_elem_free(p_cont_elem_t* ptr)
606{
607 if (!ptr)
608 return;
609 rts_syntax_id_free(ptr->transfer_syntaxes);
610 free(ptr);
611}
612
613WINPR_ATTR_MALLOC(rts_context_elem_free, 1)
614WINPR_ATTR_NODISCARD
615static p_cont_elem_t* rts_context_elem_new(size_t count)
616{
617 p_cont_elem_t* ctx = calloc(count, sizeof(p_cont_elem_t));
618 return ctx;
619}
620
621static BOOL rts_read_context_elem(wStream* s, p_cont_elem_t* element, BOOL silent)
622{
623 WINPR_ASSERT(s);
624 WINPR_ASSERT(element);
625
626 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 4, silent))
627 return FALSE;
628
629 Stream_Read_UINT16(s, element->p_cont_id);
630 Stream_Read_UINT8(s, element->n_transfer_syn); /* number of items */
631 Stream_Read_UINT8(s, element->reserved); /* alignment pad, m.b.z. */
632
633 if (!rts_read_syntax_id(s, &element->abstract_syntax, silent)) /* transfer syntax list */
634 return FALSE;
635
636 if (element->n_transfer_syn > 0)
637 {
638 element->transfer_syntaxes = rts_syntax_id_new(element->n_transfer_syn);
639 if (!element->transfer_syntaxes)
640 return FALSE;
641 for (BYTE x = 0; x < element->n_transfer_syn; x++)
642 {
643 p_syntax_id_t* syn = &element->transfer_syntaxes[x];
644 if (!rts_read_syntax_id(s, syn, silent)) /* size_is(n_transfer_syn) */
645 return FALSE;
646 }
647 }
648
649 return TRUE;
650}
651
652static BOOL rts_write_context_elem(wStream* s, const p_cont_elem_t* element)
653{
654 WINPR_ASSERT(s);
655 WINPR_ASSERT(element);
656
657 if (!Stream_EnsureRemainingCapacity(s, 4))
658 return FALSE;
659 Stream_Write_UINT16(s, element->p_cont_id);
660 Stream_Write_UINT8(s, element->n_transfer_syn); /* number of items */
661 Stream_Write_UINT8(s, element->reserved); /* alignment pad, m.b.z. */
662 if (!rts_write_syntax_id(s, &element->abstract_syntax)) /* transfer syntax list */
663 return FALSE;
664
665 for (BYTE x = 0; x < element->n_transfer_syn; x++)
666 {
667 const p_syntax_id_t* syn = &element->transfer_syntaxes[x];
668 if (!rts_write_syntax_id(s, syn)) /* size_is(n_transfer_syn) */
669 return FALSE;
670 }
671
672 return TRUE;
673}
674
675static BOOL rts_read_context_list(wStream* s, p_cont_list_t* list, BOOL silent)
676{
677 WINPR_ASSERT(s);
678 WINPR_ASSERT(list);
679
680 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 4, silent))
681 return FALSE;
682 Stream_Read_UINT8(s, list->n_context_elem); /* number of items */
683 Stream_Read_UINT8(s, list->reserved); /* alignment pad, m.b.z. */
684 Stream_Read_UINT16(s, list->reserved2); /* alignment pad, m.b.z. */
685
686 if (list->n_context_elem > 0)
687 {
688 list->p_cont_elem = rts_context_elem_new(list->n_context_elem);
689 if (!list->p_cont_elem)
690 return FALSE;
691 for (BYTE x = 0; x < list->n_context_elem; x++)
692 {
693 p_cont_elem_t* element = &list->p_cont_elem[x];
694 if (!rts_read_context_elem(s, element, silent))
695 return FALSE;
696 }
697 }
698 return TRUE;
699}
700
701static void rts_free_context_list(p_cont_list_t* list)
702{
703 if (!list)
704 return;
705 rts_context_elem_free(list->p_cont_elem);
706}
707
708static BOOL rts_write_context_list(wStream* s, const p_cont_list_t* list)
709{
710 WINPR_ASSERT(s);
711 WINPR_ASSERT(list);
712
713 if (!Stream_EnsureRemainingCapacity(s, 4))
714 return FALSE;
715 Stream_Write_UINT8(s, list->n_context_elem); /* number of items */
716 Stream_Write_UINT8(s, 0); /* alignment pad, m.b.z. */
717 Stream_Write_UINT16(s, 0); /* alignment pad, m.b.z. */
718
719 for (BYTE x = 0; x < list->n_context_elem; x++)
720 {
721 const p_cont_elem_t* element = &list->p_cont_elem[x];
722 if (!rts_write_context_elem(s, element))
723 return FALSE;
724 }
725 return TRUE;
726}
727
728static p_result_t* rts_result_new(size_t count)
729{
730 return calloc(count, sizeof(p_result_t));
731}
732
733static void rts_result_free(p_result_t* results)
734{
735 if (!results)
736 return;
737 free(results);
738}
739
740static BOOL rts_read_result(wStream* s, p_result_t* result, BOOL silent)
741{
742 WINPR_ASSERT(s);
743 WINPR_ASSERT(result);
744
745 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 2, silent))
746 return FALSE;
747
748 const UINT16 res = Stream_Get_UINT16(s);
749 switch (res)
750 {
751 case acceptance:
752 case user_rejection:
753 case provider_rejection:
754 case negotiate_ack:
755 break;
756 default:
757 WLog_ERR(TAG, "Invalid p_cont_def_result_t %" PRIu16, res);
758 return FALSE;
759 }
760 result->result = (p_cont_def_result_t)res;
761
762 const UINT16 reason = Stream_Get_UINT16(s);
763 switch (reason)
764 {
765 case reason_not_specified:
766 case abstract_syntax_not_supported:
767 case proposed_transfer_syntaxes_not_supported:
768 case local_limit_exceeded:
769 break;
770 default:
771 WLog_ERR(TAG, "Invalid p_provider_reason_t %" PRIu16, reason);
772 return FALSE;
773 }
774 result->reason = (p_provider_reason_t)reason;
775 return rts_read_syntax_id(s, &result->transfer_syntax, silent);
776}
777
778static void rts_free_result(p_result_t* result)
779{
780 if (!result)
781 return;
782}
783
784static BOOL rts_read_result_list(wStream* s, p_result_list_t* list, BOOL silent)
785{
786 WINPR_ASSERT(s);
787 WINPR_ASSERT(list);
788
789 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 4, silent))
790 return FALSE;
791 Stream_Read_UINT8(s, list->n_results); /* count */
792 Stream_Read_UINT8(s, list->reserved); /* alignment pad, m.b.z. */
793 Stream_Read_UINT16(s, list->reserved2); /* alignment pad, m.b.z. */
794
795 if (list->n_results > 0)
796 {
797 list->p_results = rts_result_new(list->n_results);
798 if (!list->p_results)
799 return FALSE;
800
801 for (BYTE x = 0; x < list->n_results; x++)
802 {
803 p_result_t* result = &list->p_results[x]; /* size_is(n_results) */
804 if (!rts_read_result(s, result, silent))
805 return FALSE;
806 }
807 }
808
809 return TRUE;
810}
811
812static void rts_free_result_list(p_result_list_t* list)
813{
814 if (!list)
815 return;
816 for (BYTE x = 0; x < list->n_results; x++)
817 {
818 p_result_t* result = &list->p_results[x];
819 rts_free_result(result);
820 }
821 rts_result_free(list->p_results);
822}
823
824static void rts_free_pdu_alter_context(rpcconn_alter_context_hdr_t* ctx)
825{
826 if (!ctx)
827 return;
828
829 rts_free_context_list(&ctx->p_context_elem);
830 rts_free_auth_verifier(&ctx->auth_verifier);
831}
832
833static BOOL rts_read_pdu_alter_context(wStream* s, rpcconn_alter_context_hdr_t* ctx, BOOL silent)
834{
835 WINPR_ASSERT(s);
836 WINPR_ASSERT(ctx);
837
838 if (!Stream_ConditionalCheckAndLogRequiredLength(
839 TAG, s, sizeof(rpcconn_alter_context_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
840 return FALSE;
841
842 Stream_Read_UINT16(s, ctx->max_xmit_frag);
843 Stream_Read_UINT16(s, ctx->max_recv_frag);
844 Stream_Read_UINT32(s, ctx->assoc_group_id);
845
846 if (!rts_read_context_list(s, &ctx->p_context_elem, silent))
847 return FALSE;
848
849 if (!rts_read_auth_verifier(s, &ctx->auth_verifier, &ctx->header, silent))
850 return FALSE;
851
852 return TRUE;
853}
854
855static BOOL rts_read_pdu_alter_context_response(wStream* s,
856 rpcconn_alter_context_response_hdr_t* ctx,
857 BOOL silent)
858{
859 WINPR_ASSERT(s);
860 WINPR_ASSERT(ctx);
861
862 if (!Stream_ConditionalCheckAndLogRequiredLength(
863 TAG, s, sizeof(rpcconn_alter_context_response_hdr_t) - sizeof(rpcconn_common_hdr_t),
864 silent))
865 return FALSE;
866 Stream_Read_UINT16(s, ctx->max_xmit_frag);
867 Stream_Read_UINT16(s, ctx->max_recv_frag);
868 Stream_Read_UINT32(s, ctx->assoc_group_id);
869
870 if (!rts_read_port_any(s, &ctx->sec_addr, silent))
871 return FALSE;
872
873 if (!rts_align_stream(s, 4, silent))
874 return FALSE;
875
876 if (!rts_read_result_list(s, &ctx->p_result_list, silent))
877 return FALSE;
878
879 if (!rts_read_auth_verifier(s, &ctx->auth_verifier, &ctx->header, silent))
880 return FALSE;
881
882 return TRUE;
883}
884
885static void rts_free_pdu_alter_context_response(rpcconn_alter_context_response_hdr_t* ctx)
886{
887 if (!ctx)
888 return;
889
890 rts_free_port_any(&ctx->sec_addr);
891 rts_free_result_list(&ctx->p_result_list);
892 rts_free_auth_verifier(&ctx->auth_verifier);
893}
894
895static BOOL rts_read_pdu_bind(wStream* s, rpcconn_bind_hdr_t* ctx, BOOL silent)
896{
897 WINPR_ASSERT(s);
898 WINPR_ASSERT(ctx);
899
900 if (!Stream_ConditionalCheckAndLogRequiredLength(
901 TAG, s, sizeof(rpcconn_bind_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
902 return FALSE;
903 Stream_Read_UINT16(s, ctx->max_xmit_frag);
904 Stream_Read_UINT16(s, ctx->max_recv_frag);
905 Stream_Read_UINT32(s, ctx->assoc_group_id);
906
907 if (!rts_read_context_list(s, &ctx->p_context_elem, silent))
908 return FALSE;
909
910 if (!rts_read_auth_verifier(s, &ctx->auth_verifier, &ctx->header, silent))
911 return FALSE;
912
913 return TRUE;
914}
915
916static void rts_free_pdu_bind(rpcconn_bind_hdr_t* ctx)
917{
918 if (!ctx)
919 return;
920 rts_free_context_list(&ctx->p_context_elem);
921 rts_free_auth_verifier(&ctx->auth_verifier);
922}
923
924static BOOL rts_read_pdu_bind_ack(wStream* s, rpcconn_bind_ack_hdr_t* ctx, BOOL silent)
925{
926 WINPR_ASSERT(s);
927 WINPR_ASSERT(ctx);
928
929 if (!Stream_CheckAndLogRequiredLength(
930 TAG, s, sizeof(rpcconn_bind_ack_hdr_t) - sizeof(rpcconn_common_hdr_t)))
931 return FALSE;
932 Stream_Read_UINT16(s, ctx->max_xmit_frag);
933 Stream_Read_UINT16(s, ctx->max_recv_frag);
934 Stream_Read_UINT32(s, ctx->assoc_group_id);
935
936 if (!rts_read_port_any(s, &ctx->sec_addr, silent))
937 return FALSE;
938
939 if (!rts_align_stream(s, 4, silent))
940 return FALSE;
941
942 if (!rts_read_result_list(s, &ctx->p_result_list, silent))
943 return FALSE;
944
945 return rts_read_auth_verifier(s, &ctx->auth_verifier, &ctx->header, silent);
946}
947
948static void rts_free_pdu_bind_ack(rpcconn_bind_ack_hdr_t* ctx)
949{
950 if (!ctx)
951 return;
952 rts_free_port_any(&ctx->sec_addr);
953 rts_free_result_list(&ctx->p_result_list);
954 rts_free_auth_verifier(&ctx->auth_verifier);
955}
956
957static BOOL rts_read_pdu_bind_nak(wStream* s, rpcconn_bind_nak_hdr_t* ctx, BOOL silent)
958{
959 WINPR_ASSERT(s);
960 WINPR_ASSERT(ctx);
961
962 if (!Stream_ConditionalCheckAndLogRequiredLength(
963 TAG, s, sizeof(rpcconn_bind_nak_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
964 return FALSE;
965 Stream_Read_UINT16(s, ctx->provider_reject_reason);
966 return rts_read_supported_versions(s, &ctx->versions, silent);
967}
968
969static void rts_free_pdu_bind_nak(rpcconn_bind_nak_hdr_t* ctx)
970{
971 if (!ctx)
972 return;
973
974 rts_free_supported_versions(&ctx->versions);
975}
976
977static BOOL rts_read_pdu_auth3(wStream* s, rpcconn_rpc_auth_3_hdr_t* ctx, BOOL silent)
978{
979 WINPR_ASSERT(s);
980 WINPR_ASSERT(ctx);
981
982 if (!Stream_ConditionalCheckAndLogRequiredLength(
983 TAG, s, sizeof(rpcconn_rpc_auth_3_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
984 return FALSE;
985 Stream_Read_UINT16(s, ctx->max_xmit_frag);
986 Stream_Read_UINT16(s, ctx->max_recv_frag);
987
988 return rts_read_auth_verifier(s, &ctx->auth_verifier, &ctx->header, silent);
989}
990
991static void rts_free_pdu_auth3(rpcconn_rpc_auth_3_hdr_t* ctx)
992{
993 if (!ctx)
994 return;
995 rts_free_auth_verifier(&ctx->auth_verifier);
996}
997
998static BOOL rts_read_pdu_fault(wStream* s, rpcconn_fault_hdr_t* ctx, BOOL silent)
999{
1000 WINPR_ASSERT(s);
1001 WINPR_ASSERT(ctx);
1002
1003 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 12, silent))
1004 return FALSE;
1005 Stream_Read_UINT32(s, ctx->alloc_hint);
1006 Stream_Read_UINT16(s, ctx->p_cont_id);
1007 Stream_Read_UINT8(s, ctx->cancel_count);
1008 Stream_Read_UINT8(s, ctx->reserved);
1009 Stream_Read_UINT32(s, ctx->status);
1010
1011 WLog_WARN(TAG, "status=%s", Win32ErrorCode2Tag(ctx->status & 0xFFFF));
1012 return rts_read_auth_verifier_with_stub(s, &ctx->auth_verifier, &ctx->header, silent);
1013}
1014
1015static void rts_free_pdu_fault(rpcconn_fault_hdr_t* ctx)
1016{
1017 if (!ctx)
1018 return;
1019 rts_free_auth_verifier(&ctx->auth_verifier);
1020}
1021
1022static BOOL rts_read_pdu_cancel_ack(wStream* s, rpcconn_cancel_hdr_t* ctx, BOOL silent)
1023{
1024 WINPR_ASSERT(s);
1025 WINPR_ASSERT(ctx);
1026
1027 if (!Stream_ConditionalCheckAndLogRequiredLength(
1028 TAG, s, sizeof(rpcconn_cancel_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
1029 return FALSE;
1030 return rts_read_auth_verifier(s, &ctx->auth_verifier, &ctx->header, silent);
1031}
1032
1033static void rts_free_pdu_cancel_ack(rpcconn_cancel_hdr_t* ctx)
1034{
1035 if (!ctx)
1036 return;
1037 rts_free_auth_verifier(&ctx->auth_verifier);
1038}
1039
1040static BOOL rts_read_pdu_orphaned(wStream* s, rpcconn_orphaned_hdr_t* ctx, BOOL silent)
1041{
1042 WINPR_ASSERT(s);
1043 WINPR_ASSERT(ctx);
1044
1045 if (!Stream_ConditionalCheckAndLogRequiredLength(
1046 TAG, s, sizeof(rpcconn_orphaned_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
1047 return FALSE;
1048 return rts_read_auth_verifier(s, &ctx->auth_verifier, &ctx->header, silent);
1049}
1050
1051static void rts_free_pdu_orphaned(rpcconn_orphaned_hdr_t* ctx)
1052{
1053 if (!ctx)
1054 return;
1055 rts_free_auth_verifier(&ctx->auth_verifier);
1056}
1057
1058static BOOL rts_read_pdu_request(wStream* s, rpcconn_request_hdr_t* ctx, BOOL silent)
1059{
1060 WINPR_ASSERT(s);
1061 WINPR_ASSERT(ctx);
1062
1063 if (!Stream_ConditionalCheckAndLogRequiredLength(
1064 TAG, s, sizeof(rpcconn_request_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
1065 return FALSE;
1066 Stream_Read_UINT32(s, ctx->alloc_hint);
1067 Stream_Read_UINT16(s, ctx->p_cont_id);
1068 Stream_Read_UINT16(s, ctx->opnum);
1069 if (!rts_read_uuid(s, &ctx->object, silent))
1070 return FALSE;
1071
1072 return rts_read_auth_verifier_with_stub(s, &ctx->auth_verifier, &ctx->header, silent);
1073}
1074
1075static void rts_free_pdu_request(rpcconn_request_hdr_t* ctx)
1076{
1077 if (!ctx)
1078 return;
1079 rts_free_auth_verifier(&ctx->auth_verifier);
1080}
1081
1082static BOOL rts_read_pdu_response(wStream* s, rpcconn_response_hdr_t* ctx, BOOL silent)
1083{
1084 WINPR_ASSERT(s);
1085 WINPR_ASSERT(ctx);
1086
1087 if (!Stream_ConditionalCheckAndLogRequiredLength(
1088 TAG, s, sizeof(rpcconn_response_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
1089 return FALSE;
1090 Stream_Read_UINT32(s, ctx->alloc_hint);
1091 Stream_Read_UINT16(s, ctx->p_cont_id);
1092 Stream_Read_UINT8(s, ctx->cancel_count);
1093 Stream_Read_UINT8(s, ctx->reserved);
1094
1095 if (!rts_align_stream(s, 8, silent))
1096 return FALSE;
1097
1098 return rts_read_auth_verifier_with_stub(s, &ctx->auth_verifier, &ctx->header, silent);
1099}
1100
1101static void rts_free_pdu_response(rpcconn_response_hdr_t* ctx)
1102{
1103 if (!ctx)
1104 return;
1105 free(ctx->stub_data);
1106 rts_free_auth_verifier(&ctx->auth_verifier);
1107}
1108
1109static BOOL rts_read_pdu_rts(wStream* s, rpcconn_rts_hdr_t* ctx, BOOL silent)
1110{
1111 WINPR_ASSERT(s);
1112 WINPR_ASSERT(ctx);
1113
1114 if (!Stream_ConditionalCheckAndLogRequiredLength(
1115 TAG, s, sizeof(rpcconn_rts_hdr_t) - sizeof(rpcconn_common_hdr_t), silent))
1116 return FALSE;
1117
1118 Stream_Read_UINT16(s, ctx->Flags);
1119 Stream_Read_UINT16(s, ctx->NumberOfCommands);
1120 return TRUE;
1121}
1122
1123static void rts_free_pdu_rts(rpcconn_rts_hdr_t* ctx)
1124{
1125 WINPR_UNUSED(ctx);
1126}
1127
1128void rts_free_pdu_header(rpcconn_hdr_t* header, BOOL allocated)
1129{
1130 if (!header)
1131 return;
1132
1133 switch (header->common.ptype)
1134 {
1135 case PTYPE_ALTER_CONTEXT:
1136 rts_free_pdu_alter_context(&header->alter_context);
1137 break;
1138 case PTYPE_ALTER_CONTEXT_RESP:
1139 rts_free_pdu_alter_context_response(&header->alter_context_response);
1140 break;
1141 case PTYPE_BIND:
1142 rts_free_pdu_bind(&header->bind);
1143 break;
1144 case PTYPE_BIND_ACK:
1145 rts_free_pdu_bind_ack(&header->bind_ack);
1146 break;
1147 case PTYPE_BIND_NAK:
1148 rts_free_pdu_bind_nak(&header->bind_nak);
1149 break;
1150 case PTYPE_RPC_AUTH_3:
1151 rts_free_pdu_auth3(&header->rpc_auth_3);
1152 break;
1153 case PTYPE_CANCEL_ACK:
1154 rts_free_pdu_cancel_ack(&header->cancel);
1155 break;
1156 case PTYPE_FAULT:
1157 rts_free_pdu_fault(&header->fault);
1158 break;
1159 case PTYPE_ORPHANED:
1160 rts_free_pdu_orphaned(&header->orphaned);
1161 break;
1162 case PTYPE_REQUEST:
1163 rts_free_pdu_request(&header->request);
1164 break;
1165 case PTYPE_RESPONSE:
1166 rts_free_pdu_response(&header->response);
1167 break;
1168 case PTYPE_RTS:
1169 rts_free_pdu_rts(&header->rts);
1170 break;
1171 /* No extra fields */
1172 case PTYPE_SHUTDOWN:
1173 break;
1174
1175 /* not handled */
1176 case PTYPE_PING:
1177 case PTYPE_WORKING:
1178 case PTYPE_NOCALL:
1179 case PTYPE_REJECT:
1180 case PTYPE_ACK:
1181 case PTYPE_CL_CANCEL:
1182 case PTYPE_FACK:
1183 case PTYPE_CO_CANCEL:
1184 default:
1185 break;
1186 }
1187
1188 if (allocated)
1189 free(header);
1190}
1191
1192BOOL rts_read_pdu_header(wStream* s, rpcconn_hdr_t* header)
1193{
1194 return rts_read_pdu_header_ex(s, header, FALSE);
1195}
1196
1197BOOL rts_read_pdu_header_ex(wStream* s, rpcconn_hdr_t* header, BOOL silent)
1198{
1199 BOOL rc = FALSE;
1200 WINPR_ASSERT(s);
1201 WINPR_ASSERT(header);
1202
1203 const rts_pdu_status_t status = rts_read_common_pdu_header(s, &header->common, silent);
1204 if (status != RTS_PDU_VALID)
1205 return FALSE;
1206
1207 WLog_DBG(TAG, "Reading PDU type %s", rts_pdu_ptype_to_string(header->common.ptype));
1208
1209 switch (header->common.ptype)
1210 {
1211 case PTYPE_ALTER_CONTEXT:
1212 rc = rts_read_pdu_alter_context(s, &header->alter_context, silent);
1213 break;
1214 case PTYPE_ALTER_CONTEXT_RESP:
1215 rc = rts_read_pdu_alter_context_response(s, &header->alter_context_response, silent);
1216 break;
1217 case PTYPE_BIND:
1218 rc = rts_read_pdu_bind(s, &header->bind, silent);
1219 break;
1220 case PTYPE_BIND_ACK:
1221 rc = rts_read_pdu_bind_ack(s, &header->bind_ack, silent);
1222 break;
1223 case PTYPE_BIND_NAK:
1224 rc = rts_read_pdu_bind_nak(s, &header->bind_nak, silent);
1225 break;
1226 case PTYPE_RPC_AUTH_3:
1227 rc = rts_read_pdu_auth3(s, &header->rpc_auth_3, silent);
1228 break;
1229 case PTYPE_CANCEL_ACK:
1230 rc = rts_read_pdu_cancel_ack(s, &header->cancel, silent);
1231 break;
1232 case PTYPE_FAULT:
1233 rc = rts_read_pdu_fault(s, &header->fault, silent);
1234 break;
1235 case PTYPE_ORPHANED:
1236 rc = rts_read_pdu_orphaned(s, &header->orphaned, silent);
1237 break;
1238 case PTYPE_REQUEST:
1239 rc = rts_read_pdu_request(s, &header->request, silent);
1240 break;
1241 case PTYPE_RESPONSE:
1242 rc = rts_read_pdu_response(s, &header->response, silent);
1243 break;
1244 case PTYPE_RTS:
1245 rc = rts_read_pdu_rts(s, &header->rts, silent);
1246 break;
1247 case PTYPE_SHUTDOWN:
1248 rc = TRUE; /* No extra fields */
1249 break;
1250
1251 /* not handled */
1252 case PTYPE_PING:
1253 case PTYPE_WORKING:
1254 case PTYPE_NOCALL:
1255 case PTYPE_REJECT:
1256 case PTYPE_ACK:
1257 case PTYPE_CL_CANCEL:
1258 case PTYPE_FACK:
1259 case PTYPE_CO_CANCEL:
1260 default:
1261 break;
1262 }
1263
1264 return rc;
1265}
1266
1267static BOOL rts_write_pdu_header(wStream* s, const rpcconn_rts_hdr_t* header)
1268{
1269 WINPR_ASSERT(s);
1270 WINPR_ASSERT(header);
1271 if (!Stream_EnsureRemainingCapacity(s, sizeof(rpcconn_rts_hdr_t)))
1272 return FALSE;
1273
1274 if (!rts_write_common_pdu_header(s, &header->header))
1275 return FALSE;
1276
1277 Stream_Write_UINT16(s, header->Flags);
1278 Stream_Write_UINT16(s, header->NumberOfCommands);
1279 return TRUE;
1280}
1281
1282/* [MS-RPCH] 2.2.3.5.1 ReceiveWindowSize */
1283static BOOL rts_receive_window_size_command_read(rdpRpc* rpc, wStream* buffer,
1284 UINT32* ReceiveWindowSize)
1285{
1286 WINPR_ASSERT(rpc);
1287 WINPR_ASSERT(buffer);
1288
1289 if (!Stream_CheckAndLogRequiredLength(TAG, buffer, 8))
1290 return FALSE;
1291 const uint32_t CommandType = Stream_Get_UINT32(buffer);
1292 if (CommandType != RTS_CMD_RECEIVE_WINDOW_SIZE)
1293 {
1294 WLog_Print(rpc->log, WLOG_ERROR,
1295 "[MS-RPCH] 2.2.3.5.1 ReceiveWindowSize::CommandType must be 0x%08" PRIx32
1296 ", got "
1297 "0x%08" PRIx32,
1298 WINPR_CXX_COMPAT_CAST(UINT32, RTS_CMD_RECEIVE_WINDOW_SIZE), CommandType);
1299 return FALSE;
1300 }
1301 const UINT32 val = Stream_Get_UINT32(buffer);
1302 if (ReceiveWindowSize)
1303 *ReceiveWindowSize = val; /* ReceiveWindowSize (4 bytes) */
1304
1305 return TRUE;
1306}
1307
1308/* [MS-RPCH] 2.2.3.5.1 ReceiveWindowSize */
1309static BOOL rts_receive_window_size_command_write(wStream* s, UINT32 ReceiveWindowSize)
1310{
1311 WINPR_ASSERT(s);
1312
1313 if (!Stream_EnsureRemainingCapacity(s, 2 * sizeof(UINT32)))
1314 return FALSE;
1315
1316 Stream_Write_UINT32(s, RTS_CMD_RECEIVE_WINDOW_SIZE); /* CommandType (4 bytes) */
1317 Stream_Write_UINT32(s, ReceiveWindowSize); /* ReceiveWindowSize (4 bytes) */
1318
1319 return TRUE;
1320}
1321
1322/* [MS-RPCH] 2.2.3.5.2 FlowControlAck */
1323static int rts_flow_control_ack_command_read(rdpRpc* rpc, wStream* buffer, UINT32* BytesReceived,
1324 UINT32* AvailableWindow, BYTE* ChannelCookie)
1325{
1326 UINT32 val = 0;
1327 UINT32 Command = 0;
1328
1329 WINPR_ASSERT(rpc);
1330 WINPR_ASSERT(buffer);
1331
1332 int rc = rts_destination_command_read(rpc, buffer, &Command);
1333 if (rc < 0)
1334 return rc;
1335
1336 if (Command != RTS_CMD_FLOW_CONTROL_ACK)
1337 {
1338 char buffer1[64] = WINPR_C_ARRAY_INIT;
1339 char buffer2[64] = WINPR_C_ARRAY_INIT;
1340 WLog_Print(rpc->log, WLOG_ERROR, "got command %s, expected %s",
1341 rts_command_to_string(Command, buffer1, sizeof(buffer1)),
1342 rts_command_to_string(RTS_CMD_FLOW_CONTROL_ACK, buffer2, sizeof(buffer2)));
1343 return -1;
1344 }
1345
1346 /* Ack (24 bytes) */
1347 if (!Stream_CheckAndLogRequiredLength(TAG, buffer, 24))
1348 return -1;
1349
1350 Stream_Read_UINT32(buffer, val);
1351 if (BytesReceived)
1352 *BytesReceived = val; /* BytesReceived (4 bytes) */
1353
1354 Stream_Read_UINT32(buffer, val);
1355 if (AvailableWindow)
1356 *AvailableWindow = val; /* AvailableWindow (4 bytes) */
1357
1358 if (ChannelCookie)
1359 Stream_Read(buffer, ChannelCookie, 16); /* ChannelCookie (16 bytes) */
1360 else
1361 Stream_Seek(buffer, 16);
1362 return 24;
1363}
1364
1365/* [MS-RPCH] 2.2.3.5.2 FlowControlAck */
1366static BOOL rts_flow_control_ack_command_write(wStream* s, UINT32 BytesReceived,
1367 UINT32 AvailableWindow, BYTE* ChannelCookie)
1368{
1369 WINPR_ASSERT(s);
1370
1371 if (!Stream_EnsureRemainingCapacity(s, 28))
1372 return FALSE;
1373
1374 Stream_Write_UINT32(s, RTS_CMD_FLOW_CONTROL_ACK); /* CommandType (4 bytes) */
1375 Stream_Write_UINT32(s, BytesReceived); /* BytesReceived (4 bytes) */
1376 Stream_Write_UINT32(s, AvailableWindow); /* AvailableWindow (4 bytes) */
1377 Stream_Write(s, ChannelCookie, 16); /* ChannelCookie (16 bytes) */
1378
1379 return TRUE;
1380}
1381
1382/* [MS-RPCH] 2.2.3.5.3 ConnectionTimeout */
1383static BOOL rts_connection_timeout_command_read(WINPR_ATTR_UNUSED rdpRpc* rpc, wStream* buffer,
1384 UINT32* ConnectionTimeout)
1385{
1386 WINPR_ASSERT(rpc);
1387 WINPR_ASSERT(buffer);
1388
1389 if (!Stream_CheckAndLogRequiredLength(TAG, buffer, 8))
1390 return FALSE;
1391
1392 const uint32_t CommandType = Stream_Get_UINT32(buffer);
1393 if (CommandType != RTS_CMD_CONNECTION_TIMEOUT)
1394 {
1395 WLog_Print(rpc->log, WLOG_ERROR,
1396 "[MS-RPCH] 2.2.3.5.3 ConnectionTimeout::CommandType must be 0x%08" PRIx32
1397 ", got "
1398 "0x%08" PRIx32,
1399 WINPR_CXX_COMPAT_CAST(UINT32, RTS_CMD_CONNECTION_TIMEOUT), CommandType);
1400 return FALSE;
1401 }
1402 const UINT32 val = Stream_Get_UINT32(buffer);
1403 if (ConnectionTimeout)
1404 *ConnectionTimeout = val; /* ConnectionTimeout (4 bytes) */
1405
1406 return TRUE;
1407}
1408
1409static BOOL rts_cookie_command_write(wStream* s, const BYTE* Cookie)
1410{
1411 WINPR_ASSERT(s);
1412
1413 if (!Stream_EnsureRemainingCapacity(s, 20))
1414 return FALSE;
1415
1416 Stream_Write_UINT32(s, RTS_CMD_COOKIE); /* CommandType (4 bytes) */
1417 Stream_Write(s, Cookie, 16); /* Cookie (16 bytes) */
1418
1419 return TRUE;
1420}
1421
1422static BOOL rts_channel_lifetime_command_write(wStream* s, UINT32 ChannelLifetime)
1423{
1424 WINPR_ASSERT(s);
1425
1426 if (!Stream_EnsureRemainingCapacity(s, 8))
1427 return FALSE;
1428 Stream_Write_UINT32(s, RTS_CMD_CHANNEL_LIFETIME); /* CommandType (4 bytes) */
1429 Stream_Write_UINT32(s, ChannelLifetime); /* ChannelLifetime (4 bytes) */
1430
1431 return TRUE;
1432}
1433
1434static BOOL rts_client_keepalive_command_write(wStream* s, UINT32 ClientKeepalive)
1435{
1436 WINPR_ASSERT(s);
1437
1438 if (!Stream_EnsureRemainingCapacity(s, 8))
1439 return FALSE;
1446 Stream_Write_UINT32(s, RTS_CMD_CLIENT_KEEPALIVE); /* CommandType (4 bytes) */
1447 Stream_Write_UINT32(s, ClientKeepalive); /* ClientKeepalive (4 bytes) */
1448
1449 return TRUE;
1450}
1451
1452/* [MS-RPCH] 2.2.3.5.7 Version */
1453static BOOL rts_version_command_read(rdpRpc* rpc, wStream* buffer, uint32_t* pversion)
1454{
1455 WINPR_ASSERT(rpc);
1456 WINPR_ASSERT(buffer);
1457
1458 if (!Stream_EnsureRemainingCapacity(buffer, 8))
1459 return FALSE;
1460
1461 const uint32_t CommandType = Stream_Get_UINT32(buffer); /* CommandType (4 bytes) */
1462 if (CommandType != RTS_CMD_VERSION)
1463 {
1464 WLog_Print(rpc->log, WLOG_ERROR,
1465 "[MS-RPCH] 2.2.3.5.7 Version::CommandType must be 0x%08" PRIx32 ", got "
1466 "0x%08" PRIx32,
1467 WINPR_CXX_COMPAT_CAST(UINT32, RTS_CMD_VERSION), CommandType);
1468 return FALSE;
1469 }
1470 const uint32_t version = Stream_Get_UINT32(buffer); /* Version (4 bytes) */
1471 if (version != 1)
1472 {
1473 WLog_Print(rpc->log, WLOG_WARN,
1474 "[MS-RPCH] 2.2.3.5.7 Version::Version should be 0x00000001, got 0x%08" PRIx32,
1475 version);
1476 }
1477 if (pversion)
1478 *pversion = version;
1479
1480 return TRUE;
1481}
1482
1483/* [MS-RPCH] 2.2.3.5.7 Version */
1484static BOOL rts_version_command_write(wStream* buffer)
1485{
1486 WINPR_ASSERT(buffer);
1487
1488 if (!Stream_EnsureRemainingCapacity((buffer), 8))
1489 return FALSE;
1490
1491 Stream_Write_UINT32(buffer, RTS_CMD_VERSION); /* CommandType (4 bytes) */
1492 Stream_Write_UINT32(buffer, 1); /* Version (4 bytes) */
1493
1494 return TRUE;
1495}
1496
1497static BOOL rts_empty_command_write(wStream* s)
1498{
1499 WINPR_ASSERT(s);
1500
1501 if (!Stream_EnsureRemainingCapacity(s, 8))
1502 return FALSE;
1503
1504 Stream_Write_UINT32(s, RTS_CMD_EMPTY); /* CommandType (4 bytes) */
1505
1506 return TRUE;
1507}
1508
1509static BOOL rts_padding_command_read(wStream* s, size_t* length, BOOL silent)
1510{
1511 UINT32 ConformanceCount = 0;
1512 WINPR_ASSERT(s);
1513 WINPR_ASSERT(length);
1514 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 4, silent))
1515 return FALSE;
1516 Stream_Read_UINT32(s, ConformanceCount); /* ConformanceCount (4 bytes) */
1517 *length = ConformanceCount + 4;
1518 return TRUE;
1519}
1520
1521static BOOL rts_client_address_command_read(wStream* s, size_t* length, BOOL silent)
1522{
1523 UINT32 AddressType = 0;
1524
1525 WINPR_ASSERT(s);
1526 WINPR_ASSERT(length);
1527
1528 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, 4, silent))
1529 return FALSE;
1530 Stream_Read_UINT32(s, AddressType); /* AddressType (4 bytes) */
1531
1532 if (AddressType == 0)
1533 {
1534 /* ClientAddress (4 bytes) */
1535 /* padding (12 bytes) */
1536 *length = 4 + 4 + 12;
1537 }
1538 else
1539 {
1540 /* ClientAddress (16 bytes) */
1541 /* padding (12 bytes) */
1542 *length = 4 + 16 + 12;
1543 }
1544 return TRUE;
1545}
1546
1547static BOOL rts_association_group_id_command_write(wStream* s, const BYTE* AssociationGroupId)
1548{
1549 WINPR_ASSERT(s);
1550
1551 if (!Stream_EnsureRemainingCapacity(s, 20))
1552 return FALSE;
1553
1554 Stream_Write_UINT32(s, RTS_CMD_ASSOCIATION_GROUP_ID); /* CommandType (4 bytes) */
1555 Stream_Write(s, AssociationGroupId, 16); /* AssociationGroupId (16 bytes) */
1556
1557 return TRUE;
1558}
1559
1560static int rts_destination_command_read(WINPR_ATTR_UNUSED rdpRpc* rpc, wStream* buffer,
1561 UINT32* Destination)
1562{
1563 UINT32 val = 0;
1564 WINPR_ASSERT(rpc);
1565 WINPR_ASSERT(buffer);
1566
1567 if (!Stream_CheckAndLogRequiredLength(TAG, buffer, 4))
1568 return -1;
1569 Stream_Read_UINT32(buffer, val);
1570 if (Destination)
1571 *Destination = val; /* Destination (4 bytes) */
1572
1573 return 4;
1574}
1575
1576static BOOL rts_destination_command_write(wStream* s, UINT32 Destination)
1577{
1578 WINPR_ASSERT(s);
1579
1580 if (!Stream_EnsureRemainingCapacity(s, 8))
1581 return FALSE;
1582
1583 Stream_Write_UINT32(s, RTS_CMD_DESTINATION); /* CommandType (4 bytes) */
1584 Stream_Write_UINT32(s, Destination); /* Destination (4 bytes) */
1585
1586 return TRUE;
1587}
1588
1589#define rts_send_buffer(channel, s, frag_length) \
1590 rts_send_buffer_int((channel), (s), (frag_length), __FILE__, __LINE__, __func__)
1591static BOOL rts_send_buffer_int(RpcChannel* channel, wStream* s, size_t frag_length,
1592 const char* file, size_t line, const char* fkt)
1593{
1594 BOOL status = FALSE;
1595 SSIZE_T rc = 0;
1596
1597 WINPR_ASSERT(channel);
1598 WINPR_ASSERT(channel->rpc);
1599 WINPR_ASSERT(s);
1600
1601 Stream_SealLength(s);
1602
1603 const DWORD level = WLOG_TRACE;
1604 if (WLog_IsLevelActive(channel->rpc->log, level))
1605 {
1606 WLog_PrintTextMessage(channel->rpc->log, level, line, file, fkt,
1607 "Sending [%s] %" PRIuz " bytes", fkt, Stream_Length(s));
1608 }
1609 if (Stream_Length(s) < sizeof(rpcconn_common_hdr_t))
1610 goto fail;
1611 if (Stream_Length(s) != frag_length)
1612 goto fail;
1613
1614 rc = rpc_channel_write(channel, Stream_Buffer(s), Stream_Length(s));
1615 if (rc < 0)
1616 goto fail;
1617 if ((size_t)rc != Stream_Length(s))
1618 goto fail;
1619 status = TRUE;
1620fail:
1621 return status;
1622}
1623
1624/* CONN/A Sequence */
1625
1626BOOL rts_send_CONN_A1_pdu(rdpRpc* rpc)
1627{
1628 BOOL status = FALSE;
1629 wStream* buffer = nullptr;
1630 rpcconn_rts_hdr_t header = rts_pdu_header_init();
1631 UINT32 ReceiveWindowSize = 0;
1632 BYTE* OUTChannelCookie = nullptr;
1633 BYTE* VirtualConnectionCookie = nullptr;
1634 RpcVirtualConnection* connection = nullptr;
1635 RpcOutChannel* outChannel = nullptr;
1636
1637 WINPR_ASSERT(rpc);
1638
1639 connection = rpc->VirtualConnection;
1640 WINPR_ASSERT(connection);
1641
1642 outChannel = connection->DefaultOutChannel;
1643 WINPR_ASSERT(outChannel);
1644
1645 header.header.frag_length = 76;
1646 header.Flags = RTS_FLAG_NONE;
1647 header.NumberOfCommands = 4;
1648
1649 WLog_DBG(TAG, "Sending CONN/A1 RTS PDU");
1650 VirtualConnectionCookie = (BYTE*)&(connection->Cookie);
1651 OUTChannelCookie = (BYTE*)&(outChannel->common.Cookie);
1652 ReceiveWindowSize = outChannel->ReceiveWindow;
1653
1654 buffer = Stream_New(nullptr, header.header.frag_length);
1655
1656 if (!buffer)
1657 return -1;
1658
1659 if (!rts_write_pdu_header(buffer, &header)) /* RTS Header (20 bytes) */
1660 goto fail;
1661 status = rts_version_command_write(buffer); /* Version (8 bytes) */
1662 if (!status)
1663 goto fail;
1664 status = rts_cookie_command_write(
1665 buffer, VirtualConnectionCookie); /* VirtualConnectionCookie (20 bytes) */
1666 if (!status)
1667 goto fail;
1668 status = rts_cookie_command_write(buffer, OUTChannelCookie); /* OUTChannelCookie (20 bytes) */
1669 if (!status)
1670 goto fail;
1671 status = rts_receive_window_size_command_write(
1672 buffer, ReceiveWindowSize); /* ReceiveWindowSize (8 bytes) */
1673 if (!status)
1674 goto fail;
1675 status = rts_send_buffer(&outChannel->common, buffer, header.header.frag_length);
1676fail:
1677 Stream_Free(buffer, TRUE);
1678 return status;
1679}
1680
1681BOOL rts_recv_CONN_A3_pdu(rdpRpc* rpc, wStream* buffer)
1682{
1683 BOOL rc = FALSE;
1684 UINT32 ConnectionTimeout = 0;
1685
1686 rpcconn_hdr_t header = WINPR_C_ARRAY_INIT;
1687 if (!rts_read_pdu_header(buffer, &header))
1688 goto fail;
1689
1690 if (header.rts.Flags != RTS_FLAG_NONE)
1691 {
1692 WLog_Print(rpc->log, WLOG_ERROR,
1693 "[MS-RPCH] 2.2.4.4 CONN/A3 RTS PDU unexpected Flags=0x%08" PRIx32
1694 ", expected 0x%08" PRIx32,
1695 header.rts.Flags, WINPR_CXX_COMPAT_CAST(UINT32, RTS_FLAG_NONE));
1696 goto fail;
1697 }
1698 if (header.rts.NumberOfCommands != 1)
1699 {
1700 WLog_Print(rpc->log, WLOG_ERROR,
1701 "[MS-RPCH] 2.2.4.4 CONN/A3 RTS PDU unexpected NumberOfCommands=%" PRIu32
1702 ", expected 1",
1703 header.rts.NumberOfCommands);
1704 goto fail;
1705 }
1706
1707 if (!rts_connection_timeout_command_read(rpc, buffer, &ConnectionTimeout))
1708 goto fail;
1709
1710 WLog_Print(rpc->log, WLOG_DEBUG, "Receiving CONN/A3 RTS PDU: ConnectionTimeout: %" PRIu32 "",
1711 ConnectionTimeout);
1712
1713 WINPR_ASSERT(rpc);
1714 WINPR_ASSERT(rpc->VirtualConnection);
1715 WINPR_ASSERT(rpc->VirtualConnection->DefaultInChannel);
1716
1717 rpc->VirtualConnection->DefaultInChannel->PingOriginator.ConnectionTimeout = ConnectionTimeout;
1718
1719 rc = TRUE;
1720
1721fail:
1722 rts_free_pdu_header(&header, FALSE);
1723 return rc;
1724}
1725
1726/* CONN/B Sequence */
1727
1728BOOL rts_send_CONN_B1_pdu(rdpRpc* rpc)
1729{
1730 BOOL status = FALSE;
1731 wStream* buffer = nullptr;
1732 rpcconn_rts_hdr_t header = rts_pdu_header_init();
1733 BYTE* INChannelCookie = nullptr;
1734 BYTE* AssociationGroupId = nullptr;
1735 BYTE* VirtualConnectionCookie = nullptr;
1736 RpcVirtualConnection* connection = nullptr;
1737 RpcInChannel* inChannel = nullptr;
1738
1739 WINPR_ASSERT(rpc);
1740
1741 connection = rpc->VirtualConnection;
1742 WINPR_ASSERT(connection);
1743
1744 inChannel = connection->DefaultInChannel;
1745 WINPR_ASSERT(inChannel);
1746
1747 header.header.frag_length = 104;
1748 header.Flags = RTS_FLAG_NONE;
1749 header.NumberOfCommands = 6;
1750
1751 WLog_DBG(TAG, "Sending CONN/B1 RTS PDU");
1752
1753 VirtualConnectionCookie = (BYTE*)&(connection->Cookie);
1754 INChannelCookie = (BYTE*)&(inChannel->common.Cookie);
1755 AssociationGroupId = (BYTE*)&(connection->AssociationGroupId);
1756 buffer = Stream_New(nullptr, header.header.frag_length);
1757
1758 if (!buffer)
1759 goto fail;
1760 if (!rts_write_pdu_header(buffer, &header)) /* RTS Header (20 bytes) */
1761 goto fail;
1762 if (!rts_version_command_write(buffer)) /* Version (8 bytes) */
1763 goto fail;
1764 if (!rts_cookie_command_write(buffer,
1765 VirtualConnectionCookie)) /* VirtualConnectionCookie (20 bytes) */
1766 goto fail;
1767 if (!rts_cookie_command_write(buffer, INChannelCookie)) /* INChannelCookie (20 bytes) */
1768 goto fail;
1769 if (!rts_channel_lifetime_command_write(buffer,
1770 rpc->ChannelLifetime)) /* ChannelLifetime (8 bytes) */
1771 goto fail;
1772 if (!rts_client_keepalive_command_write(buffer,
1773 rpc->KeepAliveInterval)) /* ClientKeepalive (8 bytes) */
1774 goto fail;
1775 if (!rts_association_group_id_command_write(
1776 buffer, AssociationGroupId)) /* AssociationGroupId (20 bytes) */
1777 goto fail;
1778 status = rts_send_buffer(&inChannel->common, buffer, header.header.frag_length);
1779fail:
1780 Stream_Free(buffer, TRUE);
1781 return status;
1782}
1783
1784/* [MS-RPCH] 2.2.4.9 CONN/C2 RTS PDU */
1785
1786BOOL rts_recv_CONN_C2_pdu(rdpRpc* rpc, wStream* buffer)
1787{
1788 BOOL rc = FALSE;
1789 UINT32 ReceiveWindowSize = 0;
1790 UINT32 ConnectionTimeout = 0;
1791
1792 WINPR_ASSERT(rpc);
1793 WINPR_ASSERT(buffer);
1794
1795 rpcconn_hdr_t header = WINPR_C_ARRAY_INIT;
1796 if (!rts_read_pdu_header(buffer, &header))
1797 goto fail;
1798
1799 if (header.rts.Flags != RTS_FLAG_NONE)
1800 {
1801 WLog_Print(rpc->log, WLOG_ERROR,
1802 "[MS-RPCH] 2.2.4.9 CONN/C2 RTS PDU unexpected Flags=0x%08" PRIx32
1803 ", expected 0x%08" PRIx32,
1804 header.rts.Flags, WINPR_CXX_COMPAT_CAST(UINT32, RTS_FLAG_NONE));
1805 goto fail;
1806 }
1807 if (header.rts.NumberOfCommands != 3)
1808 {
1809 WLog_Print(rpc->log, WLOG_ERROR,
1810 "[MS-RPCH] 2.2.4.9 CONN/C2 RTS PDU unexpected NumberOfCommands=%" PRIu32
1811 ", expected 3",
1812 header.rts.NumberOfCommands);
1813 goto fail;
1814 }
1815 if (!rts_version_command_read(rpc, buffer, nullptr))
1816 goto fail;
1817
1818 if (!rts_receive_window_size_command_read(rpc, buffer, &ReceiveWindowSize))
1819 goto fail;
1820
1821 if (!rts_connection_timeout_command_read(rpc, buffer, &ConnectionTimeout))
1822 goto fail;
1823
1824 WLog_Print(rpc->log, WLOG_DEBUG,
1825 "Receiving CONN/C2 RTS PDU: ConnectionTimeout: %" PRIu32
1826 " ReceiveWindowSize: %" PRIu32 "",
1827 ConnectionTimeout, ReceiveWindowSize);
1828
1829 WINPR_ASSERT(rpc);
1830 WINPR_ASSERT(rpc->VirtualConnection);
1831 WINPR_ASSERT(rpc->VirtualConnection->DefaultInChannel);
1832
1833 rpc->VirtualConnection->DefaultInChannel->PingOriginator.ConnectionTimeout = ConnectionTimeout;
1834 rpc->VirtualConnection->DefaultInChannel->PeerReceiveWindow = ReceiveWindowSize;
1835
1836 rc = TRUE;
1837
1838fail:
1839 rts_free_pdu_header(&header, FALSE);
1840 return rc;
1841}
1842
1843/* Out-of-Sequence PDUs */
1844
1845BOOL rts_send_flow_control_ack_pdu(rdpRpc* rpc)
1846{
1847 BOOL status = FALSE;
1848 wStream* buffer = nullptr;
1849 rpcconn_rts_hdr_t header = rts_pdu_header_init();
1850 UINT32 BytesReceived = 0;
1851 UINT32 AvailableWindow = 0;
1852 BYTE* ChannelCookie = nullptr;
1853 RpcVirtualConnection* connection = nullptr;
1854 RpcInChannel* inChannel = nullptr;
1855 RpcOutChannel* outChannel = nullptr;
1856
1857 WINPR_ASSERT(rpc);
1858
1859 connection = rpc->VirtualConnection;
1860 WINPR_ASSERT(connection);
1861
1862 inChannel = connection->DefaultInChannel;
1863 WINPR_ASSERT(inChannel);
1864
1865 outChannel = connection->DefaultOutChannel;
1866 WINPR_ASSERT(outChannel);
1867
1868 header.header.frag_length = 56;
1869 header.Flags = RTS_FLAG_OTHER_CMD;
1870 header.NumberOfCommands = 2;
1871
1872 WLog_DBG(TAG, "Sending FlowControlAck RTS PDU");
1873
1874 BytesReceived = outChannel->BytesReceived;
1875 AvailableWindow = outChannel->AvailableWindowAdvertised;
1876 ChannelCookie = (BYTE*)&(outChannel->common.Cookie);
1877 outChannel->ReceiverAvailableWindow = outChannel->AvailableWindowAdvertised;
1878 buffer = Stream_New(nullptr, header.header.frag_length);
1879
1880 if (!buffer)
1881 goto fail;
1882
1883 if (!rts_write_pdu_header(buffer, &header)) /* RTS Header (20 bytes) */
1884 goto fail;
1885 if (!rts_destination_command_write(buffer, FDOutProxy)) /* Destination Command (8 bytes) */
1886 goto fail;
1887
1888 /* FlowControlAck Command (28 bytes) */
1889 if (!rts_flow_control_ack_command_write(buffer, BytesReceived, AvailableWindow, ChannelCookie))
1890 goto fail;
1891
1892 status = rts_send_buffer(&inChannel->common, buffer, header.header.frag_length);
1893fail:
1894 Stream_Free(buffer, TRUE);
1895 return status;
1896}
1897
1898static int rts_recv_flow_control_ack_pdu(rdpRpc* rpc, wStream* buffer)
1899{
1900 int rc = 0;
1901 UINT32 BytesReceived = 0;
1902 UINT32 AvailableWindow = 0;
1903 BYTE ChannelCookie[16] = WINPR_C_ARRAY_INIT;
1904
1905 rc = rts_flow_control_ack_command_read(rpc, buffer, &BytesReceived, &AvailableWindow,
1906 (BYTE*)&ChannelCookie);
1907 if (rc < 0)
1908 return rc;
1909 WLog_ERR(TAG,
1910 "Receiving FlowControlAck RTS PDU: BytesReceived: %" PRIu32
1911 " AvailableWindow: %" PRIu32 "",
1912 BytesReceived, AvailableWindow);
1913
1914 WINPR_ASSERT(rpc->VirtualConnection);
1915 WINPR_ASSERT(rpc->VirtualConnection->DefaultInChannel);
1916
1917 rpc->VirtualConnection->DefaultInChannel->SenderAvailableWindow =
1918 AvailableWindow - (rpc->VirtualConnection->DefaultInChannel->BytesSent - BytesReceived);
1919 return 1;
1920}
1921
1922static int rts_recv_flow_control_ack_with_destination_pdu(rdpRpc* rpc, wStream* buffer)
1923{
1924 UINT32 Command = 0;
1925 UINT32 Destination = 0;
1926 UINT32 BytesReceived = 0;
1927 UINT32 AvailableWindow = 0;
1928 BYTE ChannelCookie[16] = WINPR_C_ARRAY_INIT;
1946 int rc = rts_destination_command_read(rpc, buffer, &Command);
1947 if (rc < 0)
1948 return rc;
1949
1950 if (Command != RTS_CMD_DESTINATION)
1951 {
1952 char buffer1[64] = WINPR_C_ARRAY_INIT;
1953 char buffer2[64] = WINPR_C_ARRAY_INIT;
1954 WLog_Print(rpc->log, WLOG_ERROR, "got command %s, expected %s",
1955 rts_command_to_string(Command, buffer1, sizeof(buffer1)),
1956 rts_command_to_string(RTS_CMD_DESTINATION, buffer2, sizeof(buffer2)));
1957 return -1;
1958 }
1959
1960 rc = rts_destination_command_read(rpc, buffer, &Destination);
1961 if (rc < 0)
1962 return rc;
1963
1964 switch (Destination)
1965 {
1966 case FDClient:
1967 break;
1968 case FDInProxy:
1969 break;
1970 case FDServer:
1971 break;
1972 case FDOutProxy:
1973 break;
1974 default:
1975 WLog_Print(rpc->log, WLOG_ERROR,
1976 "got destination %" PRIu32
1977 ", expected one of [FDClient[0]|FDInProxy[1]|FDServer[2]|FDOutProxy[3]",
1978 Destination);
1979 return -1;
1980 }
1981
1982 rc = rts_flow_control_ack_command_read(rpc, buffer, &BytesReceived, &AvailableWindow,
1983 ChannelCookie);
1984 if (rc < 0)
1985 return rc;
1986
1987 WLog_DBG(TAG,
1988 "Receiving FlowControlAckWithDestination RTS PDU: BytesReceived: %" PRIu32
1989 " AvailableWindow: %" PRIu32 "",
1990 BytesReceived, AvailableWindow);
1991
1992 WINPR_ASSERT(rpc->VirtualConnection);
1993 WINPR_ASSERT(rpc->VirtualConnection->DefaultInChannel);
1994 rpc->VirtualConnection->DefaultInChannel->SenderAvailableWindow =
1995 AvailableWindow - (rpc->VirtualConnection->DefaultInChannel->BytesSent - BytesReceived);
1996 return 1;
1997}
1998
1999BOOL rts_recv_ping_pdu(rdpRpc* rpc, wStream* s)
2000{
2001 BOOL rc = FALSE;
2002 rpcconn_hdr_t header = WINPR_C_ARRAY_INIT;
2003
2004 WINPR_ASSERT(rpc);
2005 WINPR_ASSERT(rpc->auth);
2006 WINPR_ASSERT(s);
2007
2008 if (!rts_read_pdu_header(s, &header))
2009 goto fail;
2010
2011 rc = TRUE;
2012 if (header.common.ptype != PTYPE_RTS)
2013 {
2014 WLog_Print(rpc->log, WLOG_ERROR, "received invalid ping PDU, type is 0x%" PRIx32,
2015 header.common.ptype);
2016 rc = FALSE;
2017 }
2018 if (header.rts.Flags != RTS_FLAG_PING)
2019 {
2020 WLog_Print(rpc->log, WLOG_ERROR, "received unexpected ping PDU::Flags 0x%" PRIx32,
2021 header.rts.Flags);
2022 rc = FALSE;
2023 }
2024fail:
2025 rts_free_pdu_header(&header, FALSE);
2026 return rc;
2027}
2028
2029static int rts_send_ping_pdu(rdpRpc* rpc)
2030{
2031 BOOL status = FALSE;
2032 wStream* buffer = nullptr;
2033 rpcconn_rts_hdr_t header = rts_pdu_header_init();
2034 RpcInChannel* inChannel = nullptr;
2035
2036 WINPR_ASSERT(rpc);
2037 WINPR_ASSERT(rpc->VirtualConnection);
2038
2039 inChannel = rpc->VirtualConnection->DefaultInChannel;
2040 WINPR_ASSERT(inChannel);
2041
2042 header.header.frag_length = 20;
2043 header.Flags = RTS_FLAG_PING;
2044 header.NumberOfCommands = 0;
2045
2046 WLog_DBG(TAG, "Sending Ping RTS PDU");
2047 buffer = Stream_New(nullptr, header.header.frag_length);
2048
2049 if (!buffer)
2050 goto fail;
2051
2052 if (!rts_write_pdu_header(buffer, &header)) /* RTS Header (20 bytes) */
2053 goto fail;
2054 status = rts_send_buffer(&inChannel->common, buffer, header.header.frag_length);
2055fail:
2056 Stream_Free(buffer, TRUE);
2057 return (status) ? 1 : -1;
2058}
2059
2060BOOL rts_command_length(UINT32 CommandType, wStream* s, size_t* length, BOOL silent)
2061{
2062 size_t padding = 0;
2063 size_t CommandLength = 0;
2064
2065 WINPR_ASSERT(s);
2066
2067 switch (CommandType)
2068 {
2069 case RTS_CMD_RECEIVE_WINDOW_SIZE:
2070 CommandLength = RTS_CMD_RECEIVE_WINDOW_SIZE_LENGTH;
2071 break;
2072
2073 case RTS_CMD_FLOW_CONTROL_ACK:
2074 CommandLength = RTS_CMD_FLOW_CONTROL_ACK_LENGTH;
2075 break;
2076
2077 case RTS_CMD_CONNECTION_TIMEOUT:
2078 CommandLength = RTS_CMD_CONNECTION_TIMEOUT_LENGTH;
2079 break;
2080
2081 case RTS_CMD_COOKIE:
2082 CommandLength = RTS_CMD_COOKIE_LENGTH;
2083 break;
2084
2085 case RTS_CMD_CHANNEL_LIFETIME:
2086 CommandLength = RTS_CMD_CHANNEL_LIFETIME_LENGTH;
2087 break;
2088
2089 case RTS_CMD_CLIENT_KEEPALIVE:
2090 CommandLength = RTS_CMD_CLIENT_KEEPALIVE_LENGTH;
2091 break;
2092
2093 case RTS_CMD_VERSION:
2094 CommandLength = RTS_CMD_VERSION_LENGTH;
2095 break;
2096
2097 case RTS_CMD_EMPTY:
2098 CommandLength = RTS_CMD_EMPTY_LENGTH;
2099 break;
2100
2101 case RTS_CMD_PADDING: /* variable-size */
2102 if (!rts_padding_command_read(s, &padding, silent))
2103 return FALSE;
2104 break;
2105
2106 case RTS_CMD_NEGATIVE_ANCE:
2107 CommandLength = RTS_CMD_NEGATIVE_ANCE_LENGTH;
2108 break;
2109
2110 case RTS_CMD_ANCE:
2111 CommandLength = RTS_CMD_ANCE_LENGTH;
2112 break;
2113
2114 case RTS_CMD_CLIENT_ADDRESS: /* variable-size */
2115 if (!rts_client_address_command_read(s, &CommandLength, silent))
2116 return FALSE;
2117 break;
2118
2119 case RTS_CMD_ASSOCIATION_GROUP_ID:
2120 CommandLength = RTS_CMD_ASSOCIATION_GROUP_ID_LENGTH;
2121 break;
2122
2123 case RTS_CMD_DESTINATION:
2124 CommandLength = RTS_CMD_DESTINATION_LENGTH;
2125 break;
2126
2127 case RTS_CMD_PING_TRAFFIC_SENT_NOTIFY:
2128 CommandLength = RTS_CMD_PING_TRAFFIC_SENT_NOTIFY_LENGTH;
2129 break;
2130
2131 default:
2132 WLog_ERR(TAG, "Error: Unknown RTS Command Type: 0x%" PRIx32 "", CommandType);
2133 return FALSE;
2134 }
2135
2136 CommandLength += padding;
2137 if (!Stream_ConditionalCheckAndLogRequiredLength(TAG, s, CommandLength, silent))
2138 return FALSE;
2139
2140 if (length)
2141 *length = CommandLength;
2142 return TRUE;
2143}
2144
2145static int rts_send_OUT_R2_A7_pdu(rdpRpc* rpc)
2146{
2147 BOOL status = FALSE;
2148 wStream* buffer = nullptr;
2149 rpcconn_rts_hdr_t header = rts_pdu_header_init();
2150 BYTE* SuccessorChannelCookie = nullptr;
2151 RpcInChannel* inChannel = nullptr;
2152 RpcOutChannel* nextOutChannel = nullptr;
2153
2154 WINPR_ASSERT(rpc);
2155 WINPR_ASSERT(rpc->VirtualConnection);
2156
2157 inChannel = rpc->VirtualConnection->DefaultInChannel;
2158 WINPR_ASSERT(inChannel);
2159
2160 nextOutChannel = rpc->VirtualConnection->NonDefaultOutChannel;
2161 WINPR_ASSERT(nextOutChannel);
2162
2163 header.header.frag_length = 56;
2164 header.Flags = RTS_FLAG_OUT_CHANNEL;
2165 header.NumberOfCommands = 3;
2166
2167 WLog_DBG(TAG, "Sending OUT_R2/A7 RTS PDU");
2168
2169 SuccessorChannelCookie = (BYTE*)&(nextOutChannel->common.Cookie);
2170 buffer = Stream_New(nullptr, header.header.frag_length);
2171
2172 if (!buffer)
2173 return -1;
2174
2175 if (!rts_write_pdu_header(buffer, &header)) /* RTS Header (20 bytes) */
2176 goto fail;
2177 if (!rts_destination_command_write(buffer, FDServer)) /* Destination (8 bytes)*/
2178 goto fail;
2179 if (!rts_cookie_command_write(buffer,
2180 SuccessorChannelCookie)) /* SuccessorChannelCookie (20 bytes) */
2181 goto fail;
2182 if (!rts_version_command_write(buffer)) /* Version (8 bytes) */
2183 goto fail;
2184 status = rts_send_buffer(&inChannel->common, buffer, header.header.frag_length);
2185fail:
2186 Stream_Free(buffer, TRUE);
2187 return (status) ? 1 : -1;
2188}
2189
2190static int rts_send_OUT_R2_C1_pdu(rdpRpc* rpc)
2191{
2192 BOOL status = FALSE;
2193 wStream* buffer = nullptr;
2194 rpcconn_rts_hdr_t header = rts_pdu_header_init();
2195 RpcOutChannel* nextOutChannel = nullptr;
2196
2197 WINPR_ASSERT(rpc);
2198 WINPR_ASSERT(rpc->VirtualConnection);
2199
2200 nextOutChannel = rpc->VirtualConnection->NonDefaultOutChannel;
2201 WINPR_ASSERT(nextOutChannel);
2202
2203 header.header.frag_length = 24;
2204 header.Flags = RTS_FLAG_PING;
2205 header.NumberOfCommands = 1;
2206
2207 WLog_DBG(TAG, "Sending OUT_R2/C1 RTS PDU");
2208 buffer = Stream_New(nullptr, header.header.frag_length);
2209
2210 if (!buffer)
2211 return -1;
2212
2213 if (!rts_write_pdu_header(buffer, &header)) /* RTS Header (20 bytes) */
2214 goto fail;
2215
2216 if (!rts_empty_command_write(buffer)) /* Empty command (4 bytes) */
2217 goto fail;
2218 status = rts_send_buffer(&nextOutChannel->common, buffer, header.header.frag_length);
2219fail:
2220 Stream_Free(buffer, TRUE);
2221 return (status) ? 1 : -1;
2222}
2223
2224BOOL rts_send_OUT_R1_A3_pdu(rdpRpc* rpc)
2225{
2226 BOOL status = FALSE;
2227 wStream* buffer = nullptr;
2228 rpcconn_rts_hdr_t header = rts_pdu_header_init();
2229 UINT32 ReceiveWindowSize = 0;
2230 BYTE* VirtualConnectionCookie = nullptr;
2231 BYTE* PredecessorChannelCookie = nullptr;
2232 BYTE* SuccessorChannelCookie = nullptr;
2233 RpcVirtualConnection* connection = nullptr;
2234 RpcOutChannel* outChannel = nullptr;
2235 RpcOutChannel* nextOutChannel = nullptr;
2236
2237 WINPR_ASSERT(rpc);
2238
2239 connection = rpc->VirtualConnection;
2240 WINPR_ASSERT(connection);
2241
2242 outChannel = connection->DefaultOutChannel;
2243 WINPR_ASSERT(outChannel);
2244
2245 nextOutChannel = connection->NonDefaultOutChannel;
2246 WINPR_ASSERT(nextOutChannel);
2247
2248 header.header.frag_length = 96;
2249 header.Flags = RTS_FLAG_RECYCLE_CHANNEL;
2250 header.NumberOfCommands = 5;
2251
2252 WLog_DBG(TAG, "Sending OUT_R1/A3 RTS PDU");
2253
2254 VirtualConnectionCookie = (BYTE*)&(connection->Cookie);
2255 PredecessorChannelCookie = (BYTE*)&(outChannel->common.Cookie);
2256 SuccessorChannelCookie = (BYTE*)&(nextOutChannel->common.Cookie);
2257 ReceiveWindowSize = outChannel->ReceiveWindow;
2258 buffer = Stream_New(nullptr, header.header.frag_length);
2259
2260 if (!buffer)
2261 return -1;
2262
2263 if (!rts_write_pdu_header(buffer, &header)) /* RTS Header (20 bytes) */
2264 goto fail;
2265 if (!rts_version_command_write(buffer)) /* Version (8 bytes) */
2266 goto fail;
2267 if (!rts_cookie_command_write(buffer,
2268 VirtualConnectionCookie)) /* VirtualConnectionCookie (20 bytes) */
2269 goto fail;
2270 if (!rts_cookie_command_write(
2271 buffer, PredecessorChannelCookie)) /* PredecessorChannelCookie (20 bytes) */
2272 goto fail;
2273 if (!rts_cookie_command_write(buffer,
2274 SuccessorChannelCookie)) /* SuccessorChannelCookie (20 bytes) */
2275 goto fail;
2276 if (!rts_receive_window_size_command_write(buffer,
2277 ReceiveWindowSize)) /* ReceiveWindowSize (8 bytes) */
2278 goto fail;
2279
2280 status = rts_send_buffer(&nextOutChannel->common, buffer, header.header.frag_length);
2281fail:
2282 Stream_Free(buffer, TRUE);
2283 return status;
2284}
2285
2286static int rts_recv_OUT_R1_A2_pdu(rdpRpc* rpc, wStream* buffer)
2287{
2288 int status = 0;
2289 UINT32 Destination = 0;
2290 WINPR_ASSERT(rpc);
2291 WINPR_ASSERT(buffer);
2292
2293 RpcVirtualConnection* connection = rpc->VirtualConnection;
2294 WINPR_ASSERT(connection);
2295
2296 WLog_DBG(TAG, "Receiving OUT R1/A2 RTS PDU");
2297
2298 status = rts_destination_command_read(rpc, buffer, &Destination);
2299 if (status < 0)
2300 return status;
2301
2302 connection->NonDefaultOutChannel = rpc_out_channel_new(rpc, &connection->Cookie);
2303
2304 if (!connection->NonDefaultOutChannel)
2305 return -1;
2306
2307 status = rpc_out_channel_replacement_connect(connection->NonDefaultOutChannel, 5000);
2308
2309 if (status < 0)
2310 {
2311 WLog_ERR(TAG, "rpc_out_channel_replacement_connect failure");
2312 return -1;
2313 }
2314
2315 rpc_out_channel_transition_to_state(connection->DefaultOutChannel,
2316 CLIENT_OUT_CHANNEL_STATE_OPENED_A6W);
2317 return 1;
2318}
2319
2320static int rts_recv_OUT_R2_A6_pdu(rdpRpc* rpc, WINPR_ATTR_UNUSED wStream* buffer)
2321{
2322 int status = 0;
2323 RpcVirtualConnection* connection = nullptr;
2324
2325 WINPR_ASSERT(rpc);
2326 WINPR_ASSERT(buffer);
2327
2328 connection = rpc->VirtualConnection;
2329 WINPR_ASSERT(connection);
2330
2331 WLog_DBG(TAG, "Receiving OUT R2/A6 RTS PDU");
2332 status = rts_send_OUT_R2_C1_pdu(rpc);
2333
2334 if (status < 0)
2335 {
2336 WLog_ERR(TAG, "rts_send_OUT_R2_C1_pdu failure");
2337 return -1;
2338 }
2339
2340 status = rts_send_OUT_R2_A7_pdu(rpc);
2341
2342 if (status < 0)
2343 {
2344 WLog_ERR(TAG, "rts_send_OUT_R2_A7_pdu failure");
2345 return -1;
2346 }
2347
2348 rpc_out_channel_transition_to_state(connection->NonDefaultOutChannel,
2349 CLIENT_OUT_CHANNEL_STATE_OPENED_B3W);
2350 rpc_out_channel_transition_to_state(connection->DefaultOutChannel,
2351 CLIENT_OUT_CHANNEL_STATE_OPENED_B3W);
2352 return 1;
2353}
2354
2355static int rts_recv_OUT_R2_B3_pdu(rdpRpc* rpc, WINPR_ATTR_UNUSED wStream* buffer)
2356{
2357 RpcVirtualConnection* connection = nullptr;
2358
2359 WINPR_ASSERT(rpc);
2360 WINPR_ASSERT(buffer);
2361
2362 connection = rpc->VirtualConnection;
2363 WINPR_ASSERT(connection);
2364
2365 WLog_DBG(TAG, "Receiving OUT R2/B3 RTS PDU");
2366 rpc_out_channel_transition_to_state(connection->DefaultOutChannel,
2367 CLIENT_OUT_CHANNEL_STATE_RECYCLED);
2368 return 1;
2369}
2370
2371BOOL rts_recv_out_of_sequence_pdu(rdpRpc* rpc, wStream* buffer, const rpcconn_hdr_t* header)
2372{
2373 BOOL status = FALSE;
2374 size_t length = 0;
2375 RtsPduSignature signature = WINPR_C_ARRAY_INIT;
2376 RpcVirtualConnection* connection = nullptr;
2377
2378 WINPR_ASSERT(rpc);
2379 WINPR_ASSERT(buffer);
2380 WINPR_ASSERT(header);
2381
2382 wLog* log = WLog_Get(TAG);
2383
2384 const size_t total = Stream_Length(buffer);
2385 length = header->common.frag_length;
2386 if (total < length)
2387 {
2388 WLog_Print(log, WLOG_ERROR, "PDU length %" PRIuz " does not match available data %" PRIuz,
2389 length, total);
2390 return FALSE;
2391 }
2392
2393 connection = rpc->VirtualConnection;
2394
2395 if (!connection)
2396 {
2397 WLog_Print(log, WLOG_ERROR, "not connected, aborting");
2398 return FALSE;
2399 }
2400
2401 if (!rts_extract_pdu_signature(&signature, buffer, header))
2402 return FALSE;
2403
2404 rts_print_pdu_signature(log, WLOG_TRACE, &signature);
2405
2406 if (memcmp(&signature, &RTS_PDU_FLOW_CONTROL_ACK_SIGNATURE, sizeof(signature)) == 0)
2407 {
2408 status = rts_recv_flow_control_ack_pdu(rpc, buffer);
2409 }
2410 else if (memcmp(&signature, &RTS_PDU_FLOW_CONTROL_ACK_WITH_DESTINATION_SIGNATURE,
2411 sizeof(signature)) == 0)
2412 {
2413 status = rts_recv_flow_control_ack_with_destination_pdu(rpc, buffer);
2414 }
2415 else if (memcmp(&signature, &RTS_PDU_PING_SIGNATURE, sizeof(signature)) == 0)
2416 {
2417 status = rts_send_ping_pdu(rpc);
2418 }
2419 else
2420 {
2421 if (connection->DefaultOutChannel->State == CLIENT_OUT_CHANNEL_STATE_OPENED)
2422 {
2423 if (memcmp(&signature, &RTS_PDU_OUT_R1_A2_SIGNATURE, sizeof(signature)) == 0)
2424 {
2425 status = rts_recv_OUT_R1_A2_pdu(rpc, buffer);
2426 }
2427 }
2428 else if (connection->DefaultOutChannel->State == CLIENT_OUT_CHANNEL_STATE_OPENED_A6W)
2429 {
2430 if (memcmp(&signature, &RTS_PDU_OUT_R2_A6_SIGNATURE, sizeof(signature)) == 0)
2431 {
2432 status = rts_recv_OUT_R2_A6_pdu(rpc, buffer);
2433 }
2434 }
2435 else if (connection->DefaultOutChannel->State == CLIENT_OUT_CHANNEL_STATE_OPENED_B3W)
2436 {
2437 if (memcmp(&signature, &RTS_PDU_OUT_R2_B3_SIGNATURE, sizeof(signature)) == 0)
2438 {
2439 status = rts_recv_OUT_R2_B3_pdu(rpc, buffer);
2440 }
2441 }
2442 }
2443
2444 if (!status)
2445 {
2446 const UINT32 SignatureId = rts_identify_pdu_signature(&signature, nullptr);
2447 WLog_Print(log, WLOG_ERROR, "error parsing RTS PDU with signature id: 0x%08" PRIX32 "",
2448 SignatureId);
2449 rts_print_pdu_signature(log, WLOG_ERROR, &signature);
2450 }
2451
2452 const size_t rem = Stream_GetRemainingLength(buffer);
2453 if (rem > 0)
2454 {
2455 WLog_Print(log, WLOG_ERROR, "%" PRIuz " bytes or %" PRIuz " total not parsed, aborting",
2456 rem, total);
2457 rts_print_pdu_signature(log, WLOG_ERROR, &signature);
2458 return FALSE;
2459 }
2460
2461 return status;
2462}
2463
2464BOOL rts_write_pdu_auth3(wStream* s, const rpcconn_rpc_auth_3_hdr_t* auth)
2465{
2466 WINPR_ASSERT(s);
2467 WINPR_ASSERT(auth);
2468
2469 if (!rts_write_common_pdu_header(s, &auth->header))
2470 return FALSE;
2471
2472 if (!Stream_EnsureRemainingCapacity(s, 2 * sizeof(UINT16)))
2473 return FALSE;
2474
2475 Stream_Write_UINT16(s, auth->max_xmit_frag);
2476 Stream_Write_UINT16(s, auth->max_recv_frag);
2477
2478 return rts_write_auth_verifier(s, &auth->auth_verifier, &auth->header);
2479}
2480
2481BOOL rts_write_pdu_bind(wStream* s, const rpcconn_bind_hdr_t* bind)
2482{
2483
2484 WINPR_ASSERT(s);
2485 WINPR_ASSERT(bind);
2486
2487 if (!rts_write_common_pdu_header(s, &bind->header))
2488 return FALSE;
2489
2490 if (!Stream_EnsureRemainingCapacity(s, 8))
2491 return FALSE;
2492
2493 Stream_Write_UINT16(s, bind->max_xmit_frag);
2494 Stream_Write_UINT16(s, bind->max_recv_frag);
2495 Stream_Write_UINT32(s, bind->assoc_group_id);
2496
2497 if (!rts_write_context_list(s, &bind->p_context_elem))
2498 return FALSE;
2499
2500 return rts_write_auth_verifier(s, &bind->auth_verifier, &bind->header);
2501}
2502
2503BOOL rts_conditional_check_and_log(const char* tag, wStream* s, size_t size, BOOL silent,
2504 const char* fkt, const char* file, size_t line)
2505{
2506 if (silent)
2507 {
2508 const size_t rem = Stream_GetRemainingLength(s);
2509 return (rem >= size);
2510 }
2511
2512 return Stream_CheckAndLogRequiredLengthEx(tag, WLOG_WARN, s, size, 1, "%s(%s:%" PRIuz ")", fkt,
2513 file, line);
2514}
2515
2516BOOL rts_conditional_safe_seek(wStream* s, size_t size, BOOL silent, const char* fkt,
2517 const char* file, size_t line)
2518{
2519 if (silent)
2520 {
2521 const size_t rem = Stream_GetRemainingLength(s);
2522 if (rem < size)
2523 return FALSE;
2524 }
2525 return Stream_SafeSeekEx(s, size, file, line, fkt);
2526}
p_cont_elem_t
Definition libfreerdp/core/gateway/rpc.h:189
p_cont_list_t
Definition libfreerdp/core/gateway/rpc.h:198
p_result_list_t
Definition libfreerdp/core/gateway/rpc.h:231
p_result_t
Definition libfreerdp/core/gateway/rpc.h:222
p_rt_versions_supported_t
Definition libfreerdp/core/gateway/rpc.h:246
p_syntax_id_t
Definition libfreerdp/core/gateway/rpc.h:183
p_uuid_t
Definition libfreerdp/core/gateway/rpc.h:150
port_any_t
Definition libfreerdp/core/gateway/rpc.h:252
rpcconn_alter_context_hdr_t
Definition libfreerdp/core/gateway/rpc.h:319
rpcconn_alter_context_response_hdr_t
Definition libfreerdp/core/gateway/rpc.h:333
rpcconn_bind_ack_hdr_t
Definition libfreerdp/core/gateway/rpc.h:363
rpcconn_bind_hdr_t
Definition libfreerdp/core/gateway/rpc.h:350
rpcconn_bind_nak_hdr_t
Definition libfreerdp/core/gateway/rpc.h:390
rpcconn_cancel_hdr_t
Definition libfreerdp/core/gateway/rpc.h:399
rpcconn_common_hdr_t
Definition libfreerdp/core/gateway/rpc.h:40
rpcconn_fault_hdr_t
Definition libfreerdp/core/gateway/rpc.h:471
rpcconn_orphaned_hdr_t
Definition libfreerdp/core/gateway/rpc.h:490
rpcconn_request_hdr_t
Definition libfreerdp/core/gateway/rpc.h:497
rpcconn_response_hdr_t
Definition libfreerdp/core/gateway/rpc.h:516
rpcconn_rpc_auth_3_hdr_t
Definition libfreerdp/core/gateway/rpc.h:380
rpcconn_rts_hdr_t
Definition libfreerdp/core/gateway/rpc.h:54
version_t
Definition libfreerdp/core/gateway/rpc.h:239
rpcconn_hdr_t
Definition libfreerdp/core/gateway/rpc.h:538