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

Source (jump to first uncovered line)
/**
 * 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: 2025-07-01 06:46

Line	Count	Source (jump to first uncovered line)
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	0	#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
70		stream_dump_read_line(FILE* fp, wStream* s, UINT64* pts, size_t* pOffset, UINT32* flags)
71	0	{
72	0	BOOL rc = FALSE;
73	0	UINT64 ts = 0;
74	0	UINT64 size = 0;
75	0	size_t r = 0;
76	0	UINT32 crc32 = 0;
77	0	BYTE received = 0;
78
79	0	if (!fp \|\| !s \|\| !flags)
80	0	return FALSE;
81
82	0	if (pOffset)
83	0	(void)_fseeki64(fp, WINPR_ASSERTING_INT_CAST(int64_t, *pOffset), SEEK_SET);
84
85	0	r = fread(&ts, 1, sizeof(ts), fp);
86	0	if (r != sizeof(ts))
87	0	goto fail;
88	0	r = fread(&received, 1, sizeof(received), fp);
89	0	if (r != sizeof(received))
90	0	goto fail;
91	0	r = fread(&crc32, 1, sizeof(crc32), fp);
92	0	if (r != sizeof(crc32))
93	0	goto fail;
94	0	r = fread(&size, 1, sizeof(size), fp);
95	0	if (r != sizeof(size))
96	0	goto fail;
97	0	if (received)
98	0	*flags = STREAM_MSG_SRV_RX;
99	0	else
100	0	*flags = STREAM_MSG_SRV_TX;
101
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
112	0	if (pOffset)
113	0	{
114	0	INT64 tmp = _ftelli64(fp);
115	0	if (tmp < 0)
116	0	goto fail;
117	0	*pOffset = (size_t)tmp;
118	0	}
119
120	0	if (pts)
121	0	*pts = ts;
122	0	rc = TRUE;
123
124	0	fail:
125	0	Stream_SealLength(s);
126	0	return rc;
127	0	}
128
129		#if !defined(BUILD_TESTING_INTERNAL)
130		static
131		#endif
132		BOOL
133		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	const int64_t rt = _ftelli64(fp);
260	0	if (rt < 0)
261	0	goto fail;
262	0	rc = WINPR_ASSERTING_INT_CAST(SSIZE_T, rt);
263	0	fail:
264	0	if (fp)
265	0	(void)fclose(fp);
266	0	return rc;
267	0	}
268
269		static int stream_dump_transport_write(rdpTransport* transport, wStream* s)
270	0	{
271	0	SSIZE_T r = 0;
272	0	rdpContext* ctx = transport_get_context(transport);
273
274	0	WINPR_ASSERT(ctx);
275	0	WINPR_ASSERT(ctx->dump);
276	0	WINPR_ASSERT(s);
277
278	0	r = stream_dump_append(ctx, ctx->dump->isServer ? STREAM_MSG_SRV_TX : STREAM_MSG_SRV_RX, s,
279	0	&ctx->dump->writeDumpOffset);
280	0	if (r < 0)
281	0	return -1;
282
283	0	WINPR_ASSERT(ctx->dump->io.WritePdu);
284	0	return ctx->dump->io.WritePdu(transport, s);
285	0	}
286
287		static int stream_dump_transport_read(rdpTransport* transport, wStream* s)
288	0	{
289	0	int rc = 0;
290	0	rdpContext* ctx = transport_get_context(transport);
291
292	0	WINPR_ASSERT(ctx);
293	0	WINPR_ASSERT(ctx->dump);
294	0	WINPR_ASSERT(s);
295
296	0	WINPR_ASSERT(ctx->dump->io.ReadPdu);
297	0	rc = ctx->dump->io.ReadPdu(transport, s);
298	0	if (rc > 0)
299	0	{
300	0	SSIZE_T r =
301	0	stream_dump_append(ctx, ctx->dump->isServer ? STREAM_MSG_SRV_RX : STREAM_MSG_SRV_TX, s,
302	0	&ctx->dump->readDumpOffset);
303	0	if (r < 0)
304	0	return -1;
305	0	}
306	0	return rc;
307	0	}
308
309		static BOOL stream_dump_register_write_handlers(rdpContext* context)
310	0	{
311	0	rdpTransportIo dump = { 0 };
312	0	const rdpTransportIo* dfl = freerdp_get_io_callbacks(context);
313
314	0	if (!freerdp_settings_get_bool(context->settings, FreeRDP_TransportDump))
315	0	return TRUE;
316
317	0	WINPR_ASSERT(dfl);
318	0	dump = *dfl;
319
320		/* Remember original callbacks for later */
321	0	WINPR_ASSERT(context->dump);
322	0	context->dump->io.ReadPdu = dfl->ReadPdu;
323	0	context->dump->io.WritePdu = dfl->WritePdu;
324
325		/* Set our dump wrappers */
326	0	dump.WritePdu = stream_dump_transport_write;
327	0	dump.ReadPdu = stream_dump_transport_read;
328	0	return freerdp_set_io_callbacks(context, &dump);
329	0	}
330
331		static int stream_dump_replay_transport_write(rdpTransport* transport, wStream* s)
332	0	{
333	0	rdpContext* ctx = transport_get_context(transport);
334	0	size_t size = 0;
335
336	0	WINPR_ASSERT(ctx);
337	0	WINPR_ASSERT(s);
338
339	0	size = Stream_Length(s);
340	0	WLog_Print(ctx->dump->log, WLOG_TRACE, "replay write %" PRIuz, size);
341		// TODO: Compare with write file
342
343	0	return 1;
344	0	}
345
346		static int stream_dump_replay_transport_read(rdpTransport* transport, wStream* s)
347	0	{
348	0	rdpContext* ctx = transport_get_context(transport);
349
350	0	size_t size = 0;
351	0	UINT64 slp = 0;
352	0	UINT64 ts = 0;
353	0	UINT32 flags = 0;
354
355	0	WINPR_ASSERT(ctx);
356	0	WINPR_ASSERT(ctx->dump);
357	0	WINPR_ASSERT(s);
358
359	0	const size_t start = Stream_GetPosition(s);
360	0	do
361	0	{
362	0	Stream_SetPosition(s, start);
363	0	if (stream_dump_get(ctx, &flags, s, &ctx->dump->replayOffset, &ts) < 0)
364	0	return -1;
365	0	} while (flags & STREAM_MSG_SRV_RX);
366
367	0	if (!ctx->dump->nodelay)
368	0	{
369	0	if ((ctx->dump->replayTime > 0) && (ts > ctx->dump->replayTime))
370	0	slp = ts - ctx->dump->replayTime;
371	0	}
372	0	ctx->dump->replayTime = ts;
373
374	0	size = Stream_Length(s);
375	0	Stream_SetPosition(s, 0);
376	0	WLog_Print(ctx->dump->log, WLOG_TRACE, "replay read %" PRIuz, size);
377
378	0	if (slp > 0)
379	0	{
380	0	uint64_t duration = slp;
381	0	do
382	0	{
383	0	const DWORD actual = (DWORD)MIN(duration, UINT32_MAX);
384	0	Sleep(actual);
385	0	duration -= actual;
386	0	} while (duration > 0);
387	0	}
388
389	0	return 1;
390	0	}
391
392		static int stream_dump_replay_transport_tcp_connect(WINPR_ATTR_UNUSED rdpContext* context,
393		WINPR_ATTR_UNUSED rdpSettings* settings,
394		WINPR_ATTR_UNUSED const char* hostname,
395		WINPR_ATTR_UNUSED int port,
396		WINPR_ATTR_UNUSED DWORD timeout)
397	0	{
398	0	WINPR_ASSERT(context);
399	0	WINPR_ASSERT(settings);
400	0	WINPR_ASSERT(hostname);
401
402	0	return 42;
403	0	}
404
405		static rdpTransportLayer* stream_dump_replay_transport_connect_layer(
406		WINPR_ATTR_UNUSED rdpTransport* transport, WINPR_ATTR_UNUSED const char* hostname,
407		WINPR_ATTR_UNUSED int port, WINPR_ATTR_UNUSED DWORD timeout)
408	0	{
409	0	WINPR_ASSERT(transport);
410	0	WINPR_ASSERT(hostname);
411
412	0	return NULL;
413	0	}
414
415		static BOOL stream_dump_replay_transport_tls_connect(WINPR_ATTR_UNUSED rdpTransport* transport)
416	0	{
417	0	WINPR_ASSERT(transport);
418	0	return TRUE;
419	0	}
420
421		static BOOL stream_dump_replay_transport_accept(WINPR_ATTR_UNUSED rdpTransport* transport)
422	0	{
423	0	WINPR_ASSERT(transport);
424	0	return TRUE;
425	0	}
426
427		static BOOL stream_dump_register_read_handlers(rdpContext* context)
428	0	{
429	0	const rdpTransportIo* dfl = freerdp_get_io_callbacks(context);
430
431	0	if (!freerdp_settings_get_bool(context->settings, FreeRDP_TransportDumpReplay))
432	0	return TRUE;
433
434	0	WINPR_ASSERT(dfl);
435	0	rdpTransportIo dump = *dfl;
436
437		/* Remember original callbacks for later */
438	0	WINPR_ASSERT(context->dump);
439	0	context->dump->nodelay =
440	0	freerdp_settings_get_bool(context->settings, FreeRDP_TransportDumpReplayNodelay);
441	0	context->dump->io.ReadPdu = dfl->ReadPdu;
442	0	context->dump->io.WritePdu = dfl->WritePdu;
443
444		/* Set our dump wrappers */
445	0	dump.WritePdu = stream_dump_transport_write;
446	0	dump.ReadPdu = stream_dump_transport_read;
447
448		/* Set our dump wrappers */
449	0	dump.WritePdu = stream_dump_replay_transport_write;
450	0	dump.ReadPdu = stream_dump_replay_transport_read;
451	0	dump.TCPConnect = stream_dump_replay_transport_tcp_connect;
452	0	dump.TLSAccept = stream_dump_replay_transport_accept;
453	0	dump.TLSConnect = stream_dump_replay_transport_tls_connect;
454	0	dump.ConnectLayer = stream_dump_replay_transport_connect_layer;
455	0	if (!freerdp_set_io_callbacks(context, &dump))
456	0	return FALSE;
457	0	return freerdp_io_callback_set_event(context, TRUE);
458	0	}
459
460		BOOL stream_dump_register_handlers(rdpContext* context, CONNECTION_STATE state, BOOL isServer)
461	0	{
462	0	WINPR_ASSERT(context);
463	0	WINPR_ASSERT(context->dump);
464	0	context->dump->state = state;
465	0	context->dump->isServer = isServer;
466	0	if (!stream_dump_register_write_handlers(context))
467	0	return FALSE;
468	0	return stream_dump_register_read_handlers(context);
469	0	}
470
471		void stream_dump_free(rdpStreamDumpContext* dump)
472	0	{
473	0	free(dump);
474	0	}
475
476		rdpStreamDumpContext* stream_dump_new(void)
477	0	{
478	0	rdpStreamDumpContext* dump = calloc(1, sizeof(rdpStreamDumpContext));
479	0	if (!dump)
480	0	return NULL;
481	0	dump->log = WLog_Get(TAG);
482
483	0	return dump;
484	0	}