/src/FreeRDP/libfreerdp/core/streamdump.c

Source
/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 *
 * RDP session stream dump interface
 *
 * Copyright 2022 Armin Novak
 * Copyright 2022 Thincast Technologies GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <time.h>

#include <winpr/sysinfo.h>
#include <winpr/path.h>
#include <winpr/string.h>

#include <freerdp/freerdp.h>
#include <freerdp/streamdump.h>
#include <freerdp/transport_io.h>

#include "streamdump.h"

#define TAG FREERDP_TAG("streamdump")

struct stream_dump_context
{
  rdpTransportIo io;
  size_t writeDumpOffset;
  size_t readDumpOffset;
  size_t replayOffset;
  UINT64 replayTime;
  CONNECTION_STATE state;
  BOOL isServer;
  BOOL nodelay;
  wLog* log;
};

static UINT32 crc32b(const BYTE* data, size_t length)
{
  UINT32 crc = 0xFFFFFFFF;

  for (size_t x = 0; x < length; x++)
  {
    const UINT32 d = data[x] & 0xFF;
    crc = crc ^ d;
    for (int j = 7; j >= 0; j--)
    {
      UINT32 mask = ~(crc & 1);
      crc = (crc >> 1) ^ (0xEDB88320 & mask);
    }
  }
  return ~crc;
}

#if !defined(BUILD_TESTING_INTERNAL)
static
#endif
    BOOL stream_dump_read_line(FILE* fp, wStream* s, UINT64* pts, size_t* pOffset, UINT32* flags)
{
  BOOL rc = FALSE;
  UINT64 ts = 0;
  UINT64 size = 0;
  size_t r = 0;
  UINT32 crc32 = 0;
  BYTE received = 0;

  if (!fp || !s || !flags)
    return FALSE;

  if (pOffset)
    (void)_fseeki64(fp, WINPR_ASSERTING_INT_CAST(int64_t, *pOffset), SEEK_SET);

  r = fread(&ts, 1, sizeof(ts), fp);
  if (r != sizeof(ts))
    goto fail;
  r = fread(&received, 1, sizeof(received), fp);
  if (r != sizeof(received))
    goto fail;
  r = fread(&crc32, 1, sizeof(crc32), fp);
  if (r != sizeof(crc32))
    goto fail;
  r = fread(&size, 1, sizeof(size), fp);
  if (r != sizeof(size))
    goto fail;
  if (received)
    *flags = STREAM_MSG_SRV_RX;
  else
    *flags = STREAM_MSG_SRV_TX;

  {
    const size_t usize = WINPR_ASSERTING_INT_CAST(size_t, size);
    if (!Stream_EnsureRemainingCapacity(s, usize))
      goto fail;
    r = fread(Stream_Pointer(s), 1, usize, fp);
    if (r != size)
      goto fail;
    if (crc32 != crc32b(Stream_ConstPointer(s), usize))
      goto fail;
    Stream_Seek(s, usize);
  }

  if (pOffset)
  {
    INT64 tmp = _ftelli64(fp);
    if (tmp < 0)
      goto fail;
    *pOffset = (size_t)tmp;
  }

  if (pts)
    *pts = ts;
  rc = TRUE;

fail:
  Stream_SealLength(s);
  return rc;
}

#if !defined(BUILD_TESTING_INTERNAL)
static
#endif
    BOOL stream_dump_write_line(FILE* fp, UINT32 flags, wStream* s)
{
  BOOL rc = FALSE;
  const UINT64 t = GetTickCount64();
  const BYTE* data = Stream_Buffer(s);
  const size_t usize = Stream_Length(s);
  const uint64_t size = (uint64_t)usize;

  if (!fp || !s)
    return FALSE;

  {
    const UINT32 crc32 = crc32b(data, usize);
    const BYTE received = flags & STREAM_MSG_SRV_RX;
    size_t r = fwrite(&t, 1, sizeof(t), fp);
    if (r != sizeof(t))
      goto fail;
    r = fwrite(&received, 1, sizeof(received), fp);
    if (r != sizeof(received))
      goto fail;
    r = fwrite(&crc32, 1, sizeof(crc32), fp);
    if (r != sizeof(crc32))
      goto fail;
    r = fwrite(&size, 1, sizeof(size), fp);
    if (r != sizeof(size))
      goto fail;
    r = fwrite(data, 1, usize, fp);
    if (r != usize)
      goto fail;
  }

  rc = TRUE;
fail:
  return rc;
}

static FILE* stream_dump_get_file(const rdpSettings* settings, const char* mode)
{
  const char* cfolder = NULL;
  char* file = NULL;
  FILE* fp = NULL;

  if (!settings || !mode)
    return NULL;

  cfolder = freerdp_settings_get_string(settings, FreeRDP_TransportDumpFile);
  if (!cfolder)
    file = GetKnownSubPath(KNOWN_PATH_TEMP, "freerdp-transport-dump");
  else
    file = _strdup(cfolder);

  if (!file)
    goto fail;

  fp = winpr_fopen(file, mode);
fail:
  free(file);
  return fp;
}

SSIZE_T stream_dump_append(const rdpContext* context, UINT32 flags, wStream* s, size_t* offset)
{
  SSIZE_T rc = -1;
  FILE* fp = NULL;
  const UINT32 mask = STREAM_MSG_SRV_RX | STREAM_MSG_SRV_TX;
  CONNECTION_STATE state = freerdp_get_state(context);
  int r = 0;

  if (!context || !s || !offset)
    return -1;

  if ((flags & STREAM_MSG_SRV_RX) && (flags & STREAM_MSG_SRV_TX))
    return -1;

  if ((flags & mask) == 0)
    return -1;

  if (state < context->dump->state)
    return 0;

  fp = stream_dump_get_file(context->settings, "ab");
  if (!fp)
    return -1;

  r = _fseeki64(fp, WINPR_ASSERTING_INT_CAST(int64_t, *offset), SEEK_SET);
  if (r < 0)
    goto fail;

  if (!stream_dump_write_line(fp, flags, s))
    goto fail;
  {
    const int64_t rt = _ftelli64(fp);
    if (rt < 0)
    {
      rc = -1;
      goto fail;
    }
    rc = WINPR_ASSERTING_INT_CAST(SSIZE_T, rt);
  }
  *offset = (size_t)rc;

fail:
  if (fp)
    (void)fclose(fp);
  return rc;
}

SSIZE_T stream_dump_get(const rdpContext* context, UINT32* flags, wStream* s, size_t* offset,
                        UINT64* pts)
{
  SSIZE_T rc = -1;
  FILE* fp = NULL;
  int r = 0;

  if (!context || !s || !offset)
    return -1;
  fp = stream_dump_get_file(context->settings, "rb");
  if (!fp)
    return -1;
  r = _fseeki64(fp, WINPR_ASSERTING_INT_CAST(int64_t, *offset), SEEK_SET);
  if (r < 0)
    goto fail;

  if (!stream_dump_read_line(fp, s, pts, offset, flags))
    goto fail;

  {
    const int64_t rt = _ftelli64(fp);
    if (rt < 0)
      goto fail;
    rc = WINPR_ASSERTING_INT_CAST(SSIZE_T, rt);
  }

fail:
  if (fp)
    (void)fclose(fp);
  return rc;
}

static int stream_dump_transport_write(rdpTransport* transport, wStream* s)
{
  SSIZE_T r = 0;
  rdpContext* ctx = transport_get_context(transport);

  WINPR_ASSERT(ctx);
  WINPR_ASSERT(ctx->dump);
  WINPR_ASSERT(s);

  r = stream_dump_append(ctx, ctx->dump->isServer ? STREAM_MSG_SRV_TX : STREAM_MSG_SRV_RX, s,
                         &ctx->dump->writeDumpOffset);
  if (r < 0)
    return -1;

  WINPR_ASSERT(ctx->dump->io.WritePdu);
  return ctx->dump->io.WritePdu(transport, s);
}

static int stream_dump_transport_read(rdpTransport* transport, wStream* s)
{
  int rc = 0;
  rdpContext* ctx = transport_get_context(transport);

  WINPR_ASSERT(ctx);
  WINPR_ASSERT(ctx->dump);
  WINPR_ASSERT(s);

  WINPR_ASSERT(ctx->dump->io.ReadPdu);
  rc = ctx->dump->io.ReadPdu(transport, s);
  if (rc > 0)
  {
    SSIZE_T r =
        stream_dump_append(ctx, ctx->dump->isServer ? STREAM_MSG_SRV_RX : STREAM_MSG_SRV_TX, s,
                           &ctx->dump->readDumpOffset);
    if (r < 0)
      return -1;
  }
  return rc;
}

static BOOL stream_dump_register_write_handlers(rdpContext* context)
{
  rdpTransportIo dump = { 0 };
  const rdpTransportIo* dfl = freerdp_get_io_callbacks(context);

  if (!freerdp_settings_get_bool(context->settings, FreeRDP_TransportDump))
    return TRUE;

  WINPR_ASSERT(dfl);
  dump = *dfl;

  /* Remember original callbacks for later */
  WINPR_ASSERT(context->dump);
  context->dump->io.ReadPdu = dfl->ReadPdu;
  context->dump->io.WritePdu = dfl->WritePdu;

  /* Set our dump wrappers */
  dump.WritePdu = stream_dump_transport_write;
  dump.ReadPdu = stream_dump_transport_read;
  return freerdp_set_io_callbacks(context, &dump);
}

static int stream_dump_replay_transport_write(rdpTransport* transport, wStream* s)
{
  rdpContext* ctx = transport_get_context(transport);
  size_t size = 0;

  WINPR_ASSERT(ctx);
  WINPR_ASSERT(s);

  size = Stream_Length(s);
  WLog_Print(ctx->dump->log, WLOG_TRACE, "replay write %" PRIuz, size);
  // TODO: Compare with write file

  return 1;
}

static int stream_dump_replay_transport_read(rdpTransport* transport, wStream* s)
{
  rdpContext* ctx = transport_get_context(transport);

  size_t size = 0;
  UINT64 slp = 0;
  UINT64 ts = 0;
  UINT32 flags = 0;

  WINPR_ASSERT(ctx);
  WINPR_ASSERT(ctx->dump);
  WINPR_ASSERT(s);

  const size_t start = Stream_GetPosition(s);
  do
  {
    Stream_SetPosition(s, start);
    if (stream_dump_get(ctx, &flags, s, &ctx->dump->replayOffset, &ts) < 0)
      return -1;
  } while (flags & STREAM_MSG_SRV_RX);

  if (!ctx->dump->nodelay)
  {
    if ((ctx->dump->replayTime > 0) && (ts > ctx->dump->replayTime))
      slp = ts - ctx->dump->replayTime;
  }
  ctx->dump->replayTime = ts;

  size = Stream_Length(s);
  Stream_SetPosition(s, 0);
  WLog_Print(ctx->dump->log, WLOG_TRACE, "replay read %" PRIuz, size);

  if (slp > 0)
  {
    uint64_t duration = slp;
    do
    {
      const DWORD actual = (DWORD)MIN(duration, UINT32_MAX);
      Sleep(actual);
      duration -= actual;
    } while (duration > 0);
  }

  return 1;
}

static int stream_dump_replay_transport_tcp_connect(WINPR_ATTR_UNUSED rdpContext* context,
                                                    WINPR_ATTR_UNUSED rdpSettings* settings,
                                                    WINPR_ATTR_UNUSED const char* hostname,
                                                    WINPR_ATTR_UNUSED int port,
                                                    WINPR_ATTR_UNUSED DWORD timeout)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(settings);
  WINPR_ASSERT(hostname);

  return 42;
}

static rdpTransportLayer* stream_dump_replay_transport_connect_layer(
    WINPR_ATTR_UNUSED rdpTransport* transport, WINPR_ATTR_UNUSED const char* hostname,
    WINPR_ATTR_UNUSED int port, WINPR_ATTR_UNUSED DWORD timeout)
{
  WINPR_ASSERT(transport);
  WINPR_ASSERT(hostname);

  return NULL;
}

static BOOL stream_dump_replay_transport_tls_connect(WINPR_ATTR_UNUSED rdpTransport* transport)
{
  WINPR_ASSERT(transport);
  return TRUE;
}

static BOOL stream_dump_replay_transport_accept(WINPR_ATTR_UNUSED rdpTransport* transport)
{
  WINPR_ASSERT(transport);
  return TRUE;
}

static BOOL stream_dump_register_read_handlers(rdpContext* context)
{
  const rdpTransportIo* dfl = freerdp_get_io_callbacks(context);

  if (!freerdp_settings_get_bool(context->settings, FreeRDP_TransportDumpReplay))
    return TRUE;

  WINPR_ASSERT(dfl);
  rdpTransportIo dump = *dfl;

  /* Remember original callbacks for later */
  WINPR_ASSERT(context->dump);
  context->dump->nodelay =
      freerdp_settings_get_bool(context->settings, FreeRDP_TransportDumpReplayNodelay);
  context->dump->io.ReadPdu = dfl->ReadPdu;
  context->dump->io.WritePdu = dfl->WritePdu;

  /* Set our dump wrappers */
  dump.WritePdu = stream_dump_transport_write;
  dump.ReadPdu = stream_dump_transport_read;

  /* Set our dump wrappers */
  dump.WritePdu = stream_dump_replay_transport_write;
  dump.ReadPdu = stream_dump_replay_transport_read;
  dump.TCPConnect = stream_dump_replay_transport_tcp_connect;
  dump.TLSAccept = stream_dump_replay_transport_accept;
  dump.TLSConnect = stream_dump_replay_transport_tls_connect;
  dump.ConnectLayer = stream_dump_replay_transport_connect_layer;
  if (!freerdp_set_io_callbacks(context, &dump))
    return FALSE;
  return freerdp_io_callback_set_event(context, TRUE);
}

BOOL stream_dump_register_handlers(rdpContext* context, CONNECTION_STATE state, BOOL isServer)
{
  WINPR_ASSERT(context);
  WINPR_ASSERT(context->dump);
  context->dump->state = state;
  context->dump->isServer = isServer;
  if (!stream_dump_register_write_handlers(context))
    return FALSE;
  return stream_dump_register_read_handlers(context);
}

void stream_dump_free(rdpStreamDumpContext* dump)
{
  free(dump);
}

rdpStreamDumpContext* stream_dump_new(void)
{
  rdpStreamDumpContext* dump = calloc(1, sizeof(rdpStreamDumpContext));
  if (!dump)
    return NULL;
  dump->log = WLog_Get(TAG);

  return dump;
}

Coverage Report

Created: 2026-01-09 06:49

Line	Count	Source
1		/**
2		* FreeRDP: A Remote Desktop Protocol Implementation
3		*
4		* RDP session stream dump interface
5		*
6		* Copyright 2022 Armin Novak
7		* Copyright 2022 Thincast Technologies GmbH
8		*
9		* Licensed under the Apache License, Version 2.0 (the "License");
10		* you may not use this file except in compliance with the License.
11		* You may obtain a copy of the License at
12		*
13		* http://www.apache.org/licenses/LICENSE-2.0
14		*
15		* Unless required by applicable law or agreed to in writing, software
16		* distributed under the License is distributed on an "AS IS" BASIS,
17		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18		* See the License for the specific language governing permissions and
19		* limitations under the License.
20		*/
21
22		#include <time.h>
23
24		#include <winpr/sysinfo.h>
25		#include <winpr/path.h>
26		#include <winpr/string.h>
27
28		#include <freerdp/freerdp.h>
29		#include <freerdp/streamdump.h>
30		#include <freerdp/transport_io.h>
31
32		#include "streamdump.h"
33
34	17.2k	#define TAG FREERDP_TAG("streamdump")
35
36		struct stream_dump_context
37		{
38		rdpTransportIo io;
39		size_t writeDumpOffset;
40		size_t readDumpOffset;
41		size_t replayOffset;
42		UINT64 replayTime;
43		CONNECTION_STATE state;
44		BOOL isServer;
45		BOOL nodelay;
46		wLog* log;
47		};
48
49		static UINT32 crc32b(const BYTE* data, size_t length)
50	0	{
51	0	UINT32 crc = 0xFFFFFFFF;
52
53	0	for (size_t x = 0; x < length; x++)
54	0	{
55	0	const UINT32 d = data[x] & 0xFF;
56	0	crc = crc ^ d;
57	0	for (int j = 7; j >= 0; j--)
58	0	{
59	0	UINT32 mask = ~(crc & 1);
60	0	crc = (crc >> 1) ^ (0xEDB88320 & mask);
61	0	}
62	0	}
63	0	return ~crc;
64	0	}
65
66		#if !defined(BUILD_TESTING_INTERNAL)
67		static
68		#endif
69		BOOL stream_dump_read_line(FILE* fp, wStream* s, UINT64* pts, size_t* pOffset, UINT32* flags)
70	0	{
71	0	BOOL rc = FALSE;
72	0	UINT64 ts = 0;
73	0	UINT64 size = 0;
74	0	size_t r = 0;
75	0	UINT32 crc32 = 0;
76	0	BYTE received = 0;
77
78	0	if (!fp \|\| !s \|\| !flags)
79	0	return FALSE;
80
81	0	if (pOffset)
82	0	(void)_fseeki64(fp, WINPR_ASSERTING_INT_CAST(int64_t, *pOffset), SEEK_SET);
83
84	0	r = fread(&ts, 1, sizeof(ts), fp);
85	0	if (r != sizeof(ts))
86	0	goto fail;
87	0	r = fread(&received, 1, sizeof(received), fp);
88	0	if (r != sizeof(received))
89	0	goto fail;
90	0	r = fread(&crc32, 1, sizeof(crc32), fp);
91	0	if (r != sizeof(crc32))
92	0	goto fail;
93	0	r = fread(&size, 1, sizeof(size), fp);
94	0	if (r != sizeof(size))
95	0	goto fail;
96	0	if (received)
97	0	*flags = STREAM_MSG_SRV_RX;
98	0	else
99	0	*flags = STREAM_MSG_SRV_TX;
100
101	0	{
102	0	const size_t usize = WINPR_ASSERTING_INT_CAST(size_t, size);
103	0	if (!Stream_EnsureRemainingCapacity(s, usize))
104	0	goto fail;
105	0	r = fread(Stream_Pointer(s), 1, usize, fp);
106	0	if (r != size)
107	0	goto fail;
108	0	if (crc32 != crc32b(Stream_ConstPointer(s), usize))
109	0	goto fail;
110	0	Stream_Seek(s, usize);
111	0	}
112
113	0	if (pOffset)
114	0	{
115	0	INT64 tmp = _ftelli64(fp);
116	0	if (tmp < 0)
117	0	goto fail;
118	0	*pOffset = (size_t)tmp;
119	0	}
120
121	0	if (pts)
122	0	*pts = ts;
123	0	rc = TRUE;
124
125	0	fail:
126	0	Stream_SealLength(s);
127	0	return rc;
128	0	}
129
130		#if !defined(BUILD_TESTING_INTERNAL)
131		static
132		#endif
133		BOOL stream_dump_write_line(FILE* fp, UINT32 flags, wStream* s)
134	0	{
135	0	BOOL rc = FALSE;
136	0	const UINT64 t = GetTickCount64();
137	0	const BYTE* data = Stream_Buffer(s);
138	0	const size_t usize = Stream_Length(s);
139	0	const uint64_t size = (uint64_t)usize;
140
141	0	if (!fp \|\| !s)
142	0	return FALSE;
143
144	0	{
145	0	const UINT32 crc32 = crc32b(data, usize);
146	0	const BYTE received = flags & STREAM_MSG_SRV_RX;
147	0	size_t r = fwrite(&t, 1, sizeof(t), fp);
148	0	if (r != sizeof(t))
149	0	goto fail;
150	0	r = fwrite(&received, 1, sizeof(received), fp);
151	0	if (r != sizeof(received))
152	0	goto fail;
153	0	r = fwrite(&crc32, 1, sizeof(crc32), fp);
154	0	if (r != sizeof(crc32))
155	0	goto fail;
156	0	r = fwrite(&size, 1, sizeof(size), fp);
157	0	if (r != sizeof(size))
158	0	goto fail;
159	0	r = fwrite(data, 1, usize, fp);
160	0	if (r != usize)
161	0	goto fail;
162	0	}
163
164	0	rc = TRUE;
165	0	fail:
166	0	return rc;
167	0	}
168
169		static FILE* stream_dump_get_file(const rdpSettings* settings, const char* mode)
170	0	{
171	0	const char* cfolder = NULL;
172	0	char* file = NULL;
173	0	FILE* fp = NULL;
174
175	0	if (!settings \|\| !mode)
176	0	return NULL;
177
178	0	cfolder = freerdp_settings_get_string(settings, FreeRDP_TransportDumpFile);
179	0	if (!cfolder)
180	0	file = GetKnownSubPath(KNOWN_PATH_TEMP, "freerdp-transport-dump");
181	0	else
182	0	file = _strdup(cfolder);
183
184	0	if (!file)
185	0	goto fail;
186
187	0	fp = winpr_fopen(file, mode);
188	0	fail:
189	0	free(file);
190	0	return fp;
191	0	}
192
193		SSIZE_T stream_dump_append(const rdpContext* context, UINT32 flags, wStream* s, size_t* offset)
194	0	{
195	0	SSIZE_T rc = -1;
196	0	FILE* fp = NULL;
197	0	const UINT32 mask = STREAM_MSG_SRV_RX \| STREAM_MSG_SRV_TX;
198	0	CONNECTION_STATE state = freerdp_get_state(context);
199	0	int r = 0;
200
201	0	if (!context \|\| !s \|\| !offset)
202	0	return -1;
203
204	0	if ((flags & STREAM_MSG_SRV_RX) && (flags & STREAM_MSG_SRV_TX))
205	0	return -1;
206
207	0	if ((flags & mask) == 0)
208	0	return -1;
209
210	0	if (state < context->dump->state)
211	0	return 0;
212
213	0	fp = stream_dump_get_file(context->settings, "ab");
214	0	if (!fp)
215	0	return -1;
216
217	0	r = _fseeki64(fp, WINPR_ASSERTING_INT_CAST(int64_t, *offset), SEEK_SET);
218	0	if (r < 0)
219	0	goto fail;
220
221	0	if (!stream_dump_write_line(fp, flags, s))
222	0	goto fail;
223	0	{
224	0	const int64_t rt = _ftelli64(fp);
225	0	if (rt < 0)
226	0	{
227	0	rc = -1;
228	0	goto fail;
229	0	}
230	0	rc = WINPR_ASSERTING_INT_CAST(SSIZE_T, rt);
231	0	}
232	0	*offset = (size_t)rc;
233
234	0	fail:
235	0	if (fp)
236	0	(void)fclose(fp);
237	0	return rc;
238	0	}
239
240		SSIZE_T stream_dump_get(const rdpContext* context, UINT32* flags, wStream* s, size_t* offset,
241		UINT64* pts)
242	0	{
243	0	SSIZE_T rc = -1;
244	0	FILE* fp = NULL;
245	0	int r = 0;
246
247	0	if (!context \|\| !s \|\| !offset)
248	0	return -1;
249	0	fp = stream_dump_get_file(context->settings, "rb");
250	0	if (!fp)
251	0	return -1;
252	0	r = _fseeki64(fp, WINPR_ASSERTING_INT_CAST(int64_t, *offset), SEEK_SET);
253	0	if (r < 0)
254	0	goto fail;
255
256	0	if (!stream_dump_read_line(fp, s, pts, offset, flags))
257	0	goto fail;
258
259	0	{
260	0	const int64_t rt = _ftelli64(fp);
261	0	if (rt < 0)
262	0	goto fail;
263	0	rc = WINPR_ASSERTING_INT_CAST(SSIZE_T, rt);
264	0	}
265
266	0	fail:
267	0	if (fp)
268	0	(void)fclose(fp);
269	0	return rc;
270	0	}
271
272		static int stream_dump_transport_write(rdpTransport* transport, wStream* s)
273	0	{
274	0	SSIZE_T r = 0;
275	0	rdpContext* ctx = transport_get_context(transport);
276
277	0	WINPR_ASSERT(ctx);
278	0	WINPR_ASSERT(ctx->dump);
279	0	WINPR_ASSERT(s);
280
281	0	r = stream_dump_append(ctx, ctx->dump->isServer ? STREAM_MSG_SRV_TX : STREAM_MSG_SRV_RX, s,
282	0	&ctx->dump->writeDumpOffset);
283	0	if (r < 0)
284	0	return -1;
285
286	0	WINPR_ASSERT(ctx->dump->io.WritePdu);
287	0	return ctx->dump->io.WritePdu(transport, s);
288	0	}
289
290		static int stream_dump_transport_read(rdpTransport* transport, wStream* s)
291	0	{
292	0	int rc = 0;
293	0	rdpContext* ctx = transport_get_context(transport);
294
295	0	WINPR_ASSERT(ctx);
296	0	WINPR_ASSERT(ctx->dump);
297	0	WINPR_ASSERT(s);
298
299	0	WINPR_ASSERT(ctx->dump->io.ReadPdu);
300	0	rc = ctx->dump->io.ReadPdu(transport, s);
301	0	if (rc > 0)
302	0	{
303	0	SSIZE_T r =
304	0	stream_dump_append(ctx, ctx->dump->isServer ? STREAM_MSG_SRV_RX : STREAM_MSG_SRV_TX, s,
305	0	&ctx->dump->readDumpOffset);
306	0	if (r < 0)
307	0	return -1;
308	0	}
309	0	return rc;
310	0	}
311
312		static BOOL stream_dump_register_write_handlers(rdpContext* context)
313	0	{
314	0	rdpTransportIo dump = { 0 };
315	0	const rdpTransportIo* dfl = freerdp_get_io_callbacks(context);
316
317	0	if (!freerdp_settings_get_bool(context->settings, FreeRDP_TransportDump))
318	0	return TRUE;
319
320	0	WINPR_ASSERT(dfl);
321	0	dump = *dfl;
322
323		/* Remember original callbacks for later */
324	0	WINPR_ASSERT(context->dump);
325	0	context->dump->io.ReadPdu = dfl->ReadPdu;
326	0	context->dump->io.WritePdu = dfl->WritePdu;
327
328		/* Set our dump wrappers */
329	0	dump.WritePdu = stream_dump_transport_write;
330	0	dump.ReadPdu = stream_dump_transport_read;
331	0	return freerdp_set_io_callbacks(context, &dump);
332	0	}
333
334		static int stream_dump_replay_transport_write(rdpTransport* transport, wStream* s)
335	0	{
336	0	rdpContext* ctx = transport_get_context(transport);
337	0	size_t size = 0;
338
339	0	WINPR_ASSERT(ctx);
340	0	WINPR_ASSERT(s);
341
342	0	size = Stream_Length(s);
343	0	WLog_Print(ctx->dump->log, WLOG_TRACE, "replay write %" PRIuz, size);
344		// TODO: Compare with write file
345
346	0	return 1;
347	0	}
348
349		static int stream_dump_replay_transport_read(rdpTransport* transport, wStream* s)
350	0	{
351	0	rdpContext* ctx = transport_get_context(transport);
352
353	0	size_t size = 0;
354	0	UINT64 slp = 0;
355	0	UINT64 ts = 0;
356	0	UINT32 flags = 0;
357
358	0	WINPR_ASSERT(ctx);
359	0	WINPR_ASSERT(ctx->dump);
360	0	WINPR_ASSERT(s);
361
362	0	const size_t start = Stream_GetPosition(s);
363	0	do
364	0	{
365	0	Stream_SetPosition(s, start);
366	0	if (stream_dump_get(ctx, &flags, s, &ctx->dump->replayOffset, &ts) < 0)
367	0	return -1;
368	0	} while (flags & STREAM_MSG_SRV_RX);
369
370	0	if (!ctx->dump->nodelay)
371	0	{
372	0	if ((ctx->dump->replayTime > 0) && (ts > ctx->dump->replayTime))
373	0	slp = ts - ctx->dump->replayTime;
374	0	}
375	0	ctx->dump->replayTime = ts;
376
377	0	size = Stream_Length(s);
378	0	Stream_SetPosition(s, 0);
379	0	WLog_Print(ctx->dump->log, WLOG_TRACE, "replay read %" PRIuz, size);
380
381	0	if (slp > 0)
382	0	{
383	0	uint64_t duration = slp;
384	0	do
385	0	{
386	0	const DWORD actual = (DWORD)MIN(duration, UINT32_MAX);
387	0	Sleep(actual);
388	0	duration -= actual;
389	0	} while (duration > 0);
390	0	}
391
392	0	return 1;
393	0	}
394
395		static int stream_dump_replay_transport_tcp_connect(WINPR_ATTR_UNUSED rdpContext* context,
396		WINPR_ATTR_UNUSED rdpSettings* settings,
397		WINPR_ATTR_UNUSED const char* hostname,
398		WINPR_ATTR_UNUSED int port,
399		WINPR_ATTR_UNUSED DWORD timeout)
400	0	{
401	0	WINPR_ASSERT(context);
402	0	WINPR_ASSERT(settings);
403	0	WINPR_ASSERT(hostname);
404
405	0	return 42;
406	0	}
407
408		static rdpTransportLayer* stream_dump_replay_transport_connect_layer(
409		WINPR_ATTR_UNUSED rdpTransport* transport, WINPR_ATTR_UNUSED const char* hostname,
410		WINPR_ATTR_UNUSED int port, WINPR_ATTR_UNUSED DWORD timeout)
411	0	{
412	0	WINPR_ASSERT(transport);
413	0	WINPR_ASSERT(hostname);
414
415	0	return NULL;
416	0	}
417
418		static BOOL stream_dump_replay_transport_tls_connect(WINPR_ATTR_UNUSED rdpTransport* transport)
419	0	{
420	0	WINPR_ASSERT(transport);
421	0	return TRUE;
422	0	}
423
424		static BOOL stream_dump_replay_transport_accept(WINPR_ATTR_UNUSED rdpTransport* transport)
425	0	{
426	0	WINPR_ASSERT(transport);
427	0	return TRUE;
428	0	}
429
430		static BOOL stream_dump_register_read_handlers(rdpContext* context)
431	0	{
432	0	const rdpTransportIo* dfl = freerdp_get_io_callbacks(context);
433
434	0	if (!freerdp_settings_get_bool(context->settings, FreeRDP_TransportDumpReplay))
435	0	return TRUE;
436
437	0	WINPR_ASSERT(dfl);
438	0	rdpTransportIo dump = *dfl;
439
440		/* Remember original callbacks for later */
441	0	WINPR_ASSERT(context->dump);
442	0	context->dump->nodelay =
443	0	freerdp_settings_get_bool(context->settings, FreeRDP_TransportDumpReplayNodelay);
444	0	context->dump->io.ReadPdu = dfl->ReadPdu;
445	0	context->dump->io.WritePdu = dfl->WritePdu;
446
447		/* Set our dump wrappers */
448	0	dump.WritePdu = stream_dump_transport_write;
449	0	dump.ReadPdu = stream_dump_transport_read;
450
451		/* Set our dump wrappers */
452	0	dump.WritePdu = stream_dump_replay_transport_write;
453	0	dump.ReadPdu = stream_dump_replay_transport_read;
454	0	dump.TCPConnect = stream_dump_replay_transport_tcp_connect;
455	0	dump.TLSAccept = stream_dump_replay_transport_accept;
456	0	dump.TLSConnect = stream_dump_replay_transport_tls_connect;
457	0	dump.ConnectLayer = stream_dump_replay_transport_connect_layer;
458	0	if (!freerdp_set_io_callbacks(context, &dump))
459	0	return FALSE;
460	0	return freerdp_io_callback_set_event(context, TRUE);
461	0	}
462
463		BOOL stream_dump_register_handlers(rdpContext* context, CONNECTION_STATE state, BOOL isServer)
464	0	{
465	0	WINPR_ASSERT(context);
466	0	WINPR_ASSERT(context->dump);
467	0	context->dump->state = state;
468	0	context->dump->isServer = isServer;
469	0	if (!stream_dump_register_write_handlers(context))
470	0	return FALSE;
471	0	return stream_dump_register_read_handlers(context);
472	0	}
473
474		void stream_dump_free(rdpStreamDumpContext* dump)
475	17.2k	{
476	17.2k	free(dump);
477	17.2k	}
478
479		rdpStreamDumpContext* stream_dump_new(void)
480	17.2k	{
481	17.2k	rdpStreamDumpContext* dump = calloc(1, sizeof(rdpStreamDumpContext));
482	17.2k	if (!dump)
483	0	return NULL;
484	17.2k	dump->log = WLog_Get(TAG);
485
486	17.2k	return dump;
487	17.2k	}