Add packet logger and server

webrtc/tools/network_tester/packet_logger.cc

Index: webrtc/tools/network_tester/packet_logger.cc
diff --git a/webrtc/tools/network_tester/packet_logger.cc b/webrtc/tools/network_tester/packet_logger.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bbd9583bce57d8bcfd941f21f7927e0acf84bb26
--- /dev/null
+++ b/webrtc/tools/network_tester/packet_logger.cc
@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#include "webrtc/tools/network_tester/packet_logger.h"
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+PacketLogger::PacketLogger(const std::string& log_file_path)
+    : packet_logger_stream_(log_file_path,
+                            std::ios_base::out | std::ios_base::binary) {
+  RTC_DCHECK(packet_logger_stream_.is_open());
+  RTC_DCHECK(packet_logger_stream_.good());
+}
+
+PacketLogger::~PacketLogger() = default;
+
+void PacketLogger::LogPacket(const NetworkTesterPacket& packet) {
+  std::string proto_data;
+  packet.SerializeToString(&proto_data);
+  RTC_DCHECK_LE(proto_data.length(), 255);
+  RTC_DCHECK_GE(proto_data.length(), 0);
+  char proto_size = proto_data.length();

[nisse-webrtc, 2017/04/06 15:00:28]

This looks better. It would be nice with a brief comment explaining the format.

I think at least proto_size should be unsigned char or uint8_t (unless you want
to change the upper limit from 255 to 127).

[michaelt, 2017/04/10 11:48:25]

Since ofstream.write just accept char* , it seams a bit strange to me to use a
uint8_t and the cast it to a char. Or would you use a different approach to
solve this problem ?

Added a comment about the format. 

[nisse-webrtc, 2017/04/10 12:05:37]

I guess we should follow the standard C++ conventions for writing binary
(non-text) files. Not sure what these are, though... One option might be to use
std::basic_ofstream<uint8_t>, but I honestly don't know if that's mainstream or
obscure.
Good!

[michaelt, 2017/04/10 12:57:21]

with std::basic_ofstream<uint8_t> we would have problem on writing the prtobuf
string then. It seams to me miss using a char pointer, to write binary data to a
file is quite accepted in the C++ community. The concept of ofstream is even
design this way. Since we can declare we will have a binary file. But we will
still have to write the file with char pointers. 

[nisse-webrtc, 2017/04/10 13:24:41]

Ok, I guess we have to stick with char pointers then.

But I think

  char proto_size = proto_data.length();

will involve undefined behavior for the range 128 <= length <= 255.
To fix that, I think you either have to limit the maximum message size to 127
bytes, or use an unsigned char / uint8_t. (Not entirely sure, though, I get no
complaints from compiling with --fsanitize=undefined).

+  packet_logger_stream_.write(&proto_size, sizeof(proto_size));
+  packet_logger_stream_.write(proto_data.data(), proto_data.length());
+}
+
+}  // namespace webrtc