DTXMessageParserTest ParseIncomingBytes_0

Author: sandin

CMakeLists.txt

@@ -44,6 +44,8 @@ set(HEADERS
     include/idevice/dtxchannel.h
     include/idevice/dtxtransport.h
     include/idevice/dtxprimitivearray.h
+    include/idevice/macro_def.h
+    include/idevice/macro_undef.h
 )
 set(SOURCES
     src/instrument.cpp
@@ -74,6 +76,7 @@ add_executable(
   test/idevice_test.cpp
   test/instrument_test.cpp
   test/dtxprimitivearray_test.cpp
+  test/dtxmessageparser_test.cpp
 )
 target_link_libraries(
   ${PROJECT_NAME}_test
@@ -84,6 +87,16 @@ add_definitions(-DENABLE_NSKEYEDARCHIVE_TEST)
 include(GoogleTest)
 gtest_discover_tests(${PROJECT_NAME}_test)
 
+# tools
+add_executable(
+  ${PROJECT_NAME}_decoder
+  tools/decoder.cpp
+)
+target_link_libraries(
+  ${PROJECT_NAME}_decoder
+  ${PROJECT_NAME}
+)
+
 # asan
 #target_compile_options(${PROJECT_NAME} PUBLIC -fsanitize=address -fno-omit-frame-pointer)
 #set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS -fsanitize=address)

include/idevice/dtxchannel.h

@@ -8,21 +8,22 @@
 
 namespace idevice {
 
-class DTXChannel : public DTXMessenger {
+class DTXChannel /*: public DTXMessenger */ {
  public:
   DTXChannel(DTXMessenger* connection, const std::string& label, uint32_t channel_identifier) : connection_(connection), label_(label), channel_identifier_(channel_identifier) {}
+  DTXChannel() : DTXChannel(nullptr, "", 0) {}
   virtual ~DTXChannel() {}
 
   // virtual bool SendMessageSync(std::shared_ptr<DTXMessage> msg, ReplyHandler callback) override;
-  virtual void SendMessageAsync(std::shared_ptr<DTXMessage> msg, ReplyHandler callback) override;
+  void SendMessageAsync(std::shared_ptr<DTXMessage> msg, DTXMessenger::ReplyHandler callback);
 
   const std::string& Label() const { return label_; }
   uint32_t ChannelIdentifier() const { return channel_identifier_; }
 
  private:
-  std::string label_;
-  uint32_t channel_identifier_;
-  DTXMessenger* connection_;
+  std::string label_ = "";
+  uint32_t channel_identifier_ = 0;
+  DTXMessenger* connection_ = nullptr;
 
 }; // class DTXChannel
 

include/idevice/dtxconnection.h

@@ -4,6 +4,7 @@
 #include <thread>
 #include <memory> // std::unique_ptr, std::shared_ptr
 #include <atomic>
+#include <utility> // std::pair
 #include <unordered_map>
 
 #include "idevice/blockingqueue.h"
@@ -19,6 +20,8 @@ namespace idevice {
 class DTXConnection : public DTXMessenger {
  public:
   using ChannelIdentifier = uint32_t;
+  using MessageIdentifier = uint32_t;
+  using DTXMessageWithRoutingInfo = std::pair<std::shared_ptr<DTXMessage>, DTXMessageRoutingInfo>;
 
   DTXConnection(DTXTransport* transport) : transport_(transport) {}
   virtual ~DTXConnection() {}
@@ -31,7 +34,7 @@ class DTXConnection : public DTXMessenger {
   bool CannelChannel(std::shared_ptr<DTXChannel> channel);
 
   // virtual bool SendMessageSync(std::shared_ptr<DTXMessage> msg, ReplyHandler callback) override;
-  virtual void SendMessageAsync(std::shared_ptr<DTXMessage> msg, ReplyHandler callback) override;
+  virtual void SendMessageAsync(std::shared_ptr<DTXMessage> msg, const DTXChannel& channel, ReplyHandler callback) override;
 
  private:
   struct Packet {
@@ -60,15 +63,19 @@ class DTXConnection : public DTXMessenger {
   std::atomic_bool parsing_thread_running_ = ATOMIC_VAR_INIT(false);
   std::unique_ptr<std::thread> parsing_thread_ = nullptr; ///< consumer of incoming packets
 
-  BlockingQueue<std::shared_ptr<DTXMessage>> send_queue_;
+  BlockingQueue<DTXMessageWithRoutingInfo> send_queue_;
   BlockingQueue<std::unique_ptr<Packet>> receive_queue_;
 
-  std::atomic<ChannelIdentifier> next_channel_code_ = ATOMIC_VAR_INIT(0);
+  std::atomic<ChannelIdentifier> next_channel_code_ = ATOMIC_VAR_INIT(1);
   std::unordered_map<ChannelIdentifier, std::shared_ptr<DTXChannel>> channels_by_code_;
 
+  std::atomic<MessageIdentifier> next_msg_identifier = ATOMIC_VAR_INIT(1);
+  
   DTXTransport* transport_;
   DTXMessageParser incoming_parser_;
   DTXMessageTransmitter outgoing_transmitter_;
+  
+  DTXChannel default_channel_;
 
 }; // class DTXConnection
 

include/idevice/dtxmessage.h

@@ -28,6 +28,7 @@ constexpr uint32_t kDTXMessageHeaderSize = sizeof(DTXMessageHeader);
 struct DTXMessageRoutingInfo {
   uint32_t identifier;
   uint32_t conversation_index;
+  uint32_t channel_code;
 };
 
 class DTXMessage {
@@ -78,6 +79,14 @@ class DTXMessage {
   void SetChannelCode(uint32_t channel_code) { channel_code_ = channel_code; }
   uint32_t ChannelCode() const { return channel_code_; }
 
+  size_t PayloadSize() const { return payload_size_; }
+  char* PayloadBuffer() const { return payload_buffer_; }
+  
+  void SetDeserialized(bool deserialized) { deserialized_ = deserialized; }
+  bool Deserialized() const { return deserialized_; }
+  
+  void Dump(bool dumphex = true) const;
+  
  private:
   void MaybeSerializeAuxiliaryObjects();
   void MaybeSerializePayloadObject();
@@ -86,13 +95,16 @@ class DTXMessage {
   char* payload_buffer_ = nullptr;
   size_t payload_size_ = 0;
   uint32_t message_type_ = 0;
-  std::unique_ptr<DTXPrimitiveArray> auxiliary_;
+  std::unique_ptr<DTXPrimitiveArray> auxiliary_ = nullptr;
   std::unordered_map<size_t, nskeyedarchiver::KAValue> auxiliary_objects_;
 
+  // DTXMessageRoutingInfo
   uint32_t identifier_ = 0;
   uint32_t conversation_index_ = 0;
   uint32_t channel_code_ = 0;
 
+  bool deserialized_ = false;
+  
 }; // class DTXMessage
 
 }  // namespace idevice

include/idevice/dtxmessageparser.h

@@ -1,6 +1,9 @@
 #ifndef IDEVICE_DTXMESSAGE_PARSER_H
 #define IDEVICE_DTXMESSAGE_PARSER_H
 
+#include <queue>
+#include <vector>
+
 #include "idevice/idevice.h"
 #include "idevice/dtxmessage.h"
 #include "idevice/bytebuffer.h"
@@ -16,12 +19,15 @@ class DTXMessageParser {
 
   bool ParseIncomingBytes(const char* buffer, size_t size);
 
+  std::vector<std::shared_ptr<DTXMessage>> PopAllParsedMessages();
+  
  private:
   //const char* Read(ByteReader& reader, size_t size, size_t* actual_size);
   bool ParseMessageWithHeader(const DTXMessageHeader& header, const char* data, size_t size);
 
   bool eof_ = false;
   BufferMemory parsing_buffer_;
+  std::queue<std::shared_ptr<DTXMessage>> parsed_message_queue_;
 }; // class DTXMessageParser
 
 }  // namespace idevice

include/idevice/dtxmessenger.h

@@ -6,6 +6,7 @@
 namespace idevice {
 
 class DTXMessage;
+class DTXChannel;
 
 // Interface
 class DTXMessenger {
@@ -15,7 +16,7 @@ class DTXMessenger {
   virtual ~DTXMessenger() {}
 
   // virtual bool SendMessageSync(std::shared_ptr<DTXMessage> msg, ReplyHandler callback) = 0;
-  virtual void SendMessageAsync(std::shared_ptr<DTXMessage> msg, ReplyHandler callback) = 0;
+  virtual void SendMessageAsync(std::shared_ptr<DTXMessage> msg, const DTXChannel& channel, ReplyHandler callback) = 0;
 }; 
 
 }  // namespace idevice

include/idevice/dtxprimitivearray.h

@@ -4,9 +4,13 @@
 #include <cstdint> // int32_t, int64_t, uint64_t
 #include <cstdlib> // malloc, free
 #include <cstring> // memcpy
+#include <string>
 #include <vector>
 #include <memory> // std::unique_ptr
 
+#include "idevice/idevice.h" // hexdump
+#include "nskeyedarchiver/nskeyedunarchiver.hpp"
+
 namespace idevice {
 
 class DTXPrimitiveValue {
@@ -131,6 +135,49 @@ class DTXPrimitiveValue {
   Type GetType() const { return t_; }
   void SetType(Type t) { t_ = t; }
 
+  void Dump(bool dumphex = true) const {
+    switch (t_) {
+      case kNull:
+        printf("[type=kNull, size=0, value=]\n");
+      case kEmptyKey:
+        printf("[type=kEmptyKey, size=0, value=]\n");
+        break;
+      case kString: {
+        size_t str_len = Size();
+        char* str = static_cast<char*>(malloc(str_len + 1));
+        strncpy(str, d_.b, str_len);
+        str[str_len] = '\0';
+        printf("[type=kString, size=%zu, value=%s]\n", Size(), str);
+        free(str);
+        break;
+      }
+      case kBuffer: {
+        if (dumphex) {
+          hexdump(d_.b, Size(), 0);
+        }
+        nskeyedarchiver::KAValue value = nskeyedarchiver::NSKeyedUnarchiver::UnarchiveTopLevelObjectWithData(d_.b, Size());
+        printf("[type=kBuffer, size=%zu, value=%s]\n", Size(), value.ToJson().c_str());
+        break;
+      }
+      case kSignedInt32:
+        printf("[type=kSignedInt32, size=%zu, value=%d]\n", Size(), d_.i32);
+        break;
+      case kSignedInt64:
+        printf("[type=kSignedInt64, size=%zu, value=%lld]\n", Size(), d_.i64);
+        break;
+      case kFloat32:
+        printf("[type=kFloat32, size=%zu, value=%f]\n", Size(), d_.f);
+        break;
+      case kFloat64:
+        printf("[type=kFloat64, size=%zu, value=%f]\n", Size(), d_.d);
+        break;
+      case kInteger:
+        printf("[type=kSignedInt64, size=%zu, value=%llu]\n", Size(), d_.u);
+      default:
+        break;
+    }
+  }
+  
  private:
   union {
     char* b;  // kString or kBuffer
@@ -175,6 +222,8 @@ class DTXPrimitiveArray {
 
   size_t Size() const { return items_.size(); }
 
+  void Dump(bool dumphex = true) const;
+  
  private:
   std::vector<DTXPrimitiveValue> items_;
   bool as_dict_ = false;

include/idevice/dtxtransport.h

@@ -6,6 +6,8 @@
 #include <cstring> // memcpy
 #include <algorithm> // std::min
 
+#include "idevice/macro_def.h"
+#include "idevice/idevice.h" // hexdump
 #include "idevice/instrument.h"
 
 namespace idevice {
@@ -58,6 +60,10 @@ class BufferedDTXTransport {
       if (!Flush()) {
         return false;
       }
+#if IDEVICE_DEBUG
+      IDEVICE_LOG_D("Send\n");
+      hexdump((void*)(data), size, 0);
+#endif
       uint32_t actual_size = 0;
       return transport_->Send(data, size, &actual_size);
     }
@@ -82,6 +88,10 @@ class BufferedDTXTransport {
       return; // nothing to do
     }
     uint32_t actual_size = 0;
+#if IDEVICE_DEBUG
+    IDEVICE_LOG_D("Flush\n");
+    hexdump(buffer_, buffer_used_, 0);
+#endif
     bool ret = transport_->Send(buffer_, buffer_used_, &actual_size);
     buffer_used_ = 0;
     return ret;

include/idevice/macro_def.h

@@ -0,0 +1,42 @@
+#ifndef IDEVICE_MACRO_DEF_H
+#define IDEVICE_MACRO_DEF_H
+
+// DEBUG 
+#ifdef NDEBUG
+#define IDEVICE_DEBUG 0
+#else
+#define IDEVICE_DEBUG 1
+#endif
+
+// LOG 
+#define IDEVICE_LOG_LEVEL 2
+#if IDEVICE_LOG_LEVEL >= 0
+#define IDEVICE_LOG_E(fmt, ...) \
+  fprintf(stderr, "[ERROR] %s:%d:%s(): " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#else
+#define IDEVICE_LOG_E(fmt, ...)
+#endif
+#if IDEVICE_LOG_LEVEL >= 1
+#define IDEVICE_LOG_I(fmt, ...) \
+  printf("[INFO] %s:%d:%s(): " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#else
+#define IDEVICE_LOG_I(fmt, ...)
+#endif
+#if IDEVICE_LOG_LEVEL >= 2
+#define IDEVICE_LOG_D(fmt, ...) \
+  printf("[DEBUG] %s:%d:%s(): " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#else
+#define IDEVICE_LOG_D(fmt, ...)
+#endif
+#if IDEVICE_LOG_LEVEL >= 3
+#define IDEVICE_LOG_V(fmt, ...) \
+  printf("[VERBOSE] %s:%d:%s(): " fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#else
+#define IDEVICE_LOG_V(fmt, ...)
+#endif
+
+// ASSERT
+#define IDEVICE_ASSERT(exp, fmt, ...) if (!(exp)) { LOG_ERROR(fmt, ##__VA_ARGS__); } assert(exp)
+
+
+#endif // IDEVICE_MACRO_SCOPE_H

include/idevice/macro_undef.h

@@ -0,0 +1,17 @@
+#ifndef IDEVICE_MACRO_UNDEF_H
+#define IDEVICE_MACRO_UNDEF_H
+
+// DEBUG
+#undef IDEVICE_DEBUG
+
+// LOG
+#undef IDEVICE_LOG_LEVEL
+#undef IDEVICE_LOG_E
+#undef IDEVICE_LOG_I
+#undef IDEVICE_LOG_D
+#undef IDEVICE_LOG_V
+
+// ASSERT
+#undef IDEVICE_ASSERT
+
+#endif // IDEVICE_MACRO_UNDEF_H