Merge pull request #1207 from AndreasAakesson/dev

tcp: Finished RFC 7323

Author: fwsGonzo

api/common

@@ -53,27 +53,11 @@
 #undef Expects
 #undef Ensures
 
-#define Expects(cond)                                       \
-  do {                                                      \
-    if (UNLIKELY(not (cond))) {                             \
-      std::cerr << "OS: Precondition (" OS_STRINGIFY(cond)  \
-                << ") failed...\n"  << "\t...in function: " \
-                << __func__ << " @" << __FILE__ << ":"      \
-                << __LINE__ << '\n';                        \
-      std::terminate();                                     \
-    }                                                       \
-  } while(0)
+#define Expects(cond) \
+  assert(LIKELY(cond) && "OS: Precondition failed")
 
-#define Ensures(cond)                                       \
-  do {                                                      \
-    if (UNLIKELY(not (cond))) {                             \
-      std::cerr << "OS: Postcondition (" OS_STRINGIFY(cond) \
-                << ") failed...\n"  << "\t...in function: " \
-                << __func__ << " @" << __FILE__ << ":"      \
-                << __LINE__ << '\n';                        \
-      std::terminate();                                     \
-    }                                                       \
-  } while(0)
+#define Ensures(cond) \
+  assert(LIKELY(cond) && "OS: Postcondition failed")
 
 #endif //< defined(OS_TERMINATE_ON_CONTRACT_VIOLATION)
 

api/net/ip4/packet_ip4.hpp

@@ -89,13 +89,11 @@ namespace net {
   protected:
     Byte* ip_data() noexcept __attribute__((assume_aligned(4)))
     {
-      Expects((size_t)(data_end() - layer_begin()) >= sizeof(IP4::header));
       return layer_begin() + ip_header_length();
     }
 
     const Byte* ip_data() const noexcept __attribute__((assume_aligned(4)))
     {
-      Expects((size_t)(data_end() - layer_begin()) >= sizeof(IP4::header));
       return layer_begin() + ip_header_length();
     }
 

api/net/tcp/common.hpp

@@ -38,6 +38,8 @@ namespace net {
     static constexpr uint16_t default_mss {536};
     // the maximum amount of half-open connections per port (listener)
     static constexpr size_t   default_max_syn_backlog {64};
+    // clock granularity of the timestamp value clock
+    static constexpr float   clock_granularity {0.0001};
 
     static const std::chrono::seconds       default_msl {30};
     static const std::chrono::milliseconds  default_dack_timeout {40};

api/net/tcp/connection.hpp

@@ -108,7 +108,7 @@ class Connection : public std::enable_shared_from_this<Connection> {
    * Emitted on RTO - When the retransmission timer times out, before retransmitting.
    * Gives the current attempt and the current timeout in seconds.
    */
-  using RtxTimeoutCallback      = delegate<void(size_t no_attempts, double rto)>;
+  using RtxTimeoutCallback      = delegate<void(size_t no_attempts, std::chrono::milliseconds rto)>;
   inline Connection&            on_rtx_timeout(RtxTimeoutCallback);
 
 
@@ -668,7 +668,7 @@ class Connection : public std::enable_shared_from_this<Connection> {
   { if(on_packet_dropped_) on_packet_dropped_(packet, reason); }
 
   void signal_rtx_timeout()
-  { if(on_rtx_timeout_) on_rtx_timeout_(rtx_attempt_+1, rttm.RTO); }
+  { if(on_rtx_timeout_) on_rtx_timeout_(rtx_attempt_+1, rttm.rto_ms()); }
 
   /*
     Drop a packet. Used for debug/callback.
@@ -830,6 +830,15 @@ class Connection : public std::enable_shared_from_this<Connection> {
   */
   void retransmit();
 
+  /**
+   * @brief      Take an RTT measurment from an incoming packet.
+   *             Uses timestamp if timestamp options are in use,
+   *             else RTTM start/stop.
+   *
+   * @param[in]  <unnamed>  An incomming TCP packet
+   */
+  void take_rtt_measure(const Packet&);
+
   /*
     Start retransmission timer.
   */
@@ -917,13 +926,22 @@ class Connection : public std::enable_shared_from_this<Connection> {
   /*
     Parse and apply options.
   */
-  void parse_options(Packet&);
+  void parse_options(const Packet&);
 
   /*
     Add an option.
   */
   void add_option(Option::Kind, Packet&);
 
+  /**
+   * @brief      Parses the timestamp option from a packet (if any).
+   *             Assumes the packet contains no other options.
+   *
+   * @param[in]  <unnamed>  A TCP packet
+   *
+   * @return     A pointer the the timestamp option (nullptr if none)
+   */
+  Option::opt_ts* parse_ts_option(const Packet&) const;
 
 }; // < class Connection
 

api/net/tcp/options.hpp

@@ -31,7 +31,7 @@ struct Option {
 
   enum Kind {
     END = 0x00, // End of option list
-    NOP = 0x01, // No-Opeartion
+    NOP = 0x01, // No-Operation
     MSS = 0x02, // Maximum Segment Size [RFC 793] Rev: [879, 6691]
     WS  = 0x03, // Window Scaling [RFC 7323] p. 8
     TS  = 0x08, // Timestamp [RFC 7323] p. 11
@@ -41,6 +41,9 @@ struct Option {
   const uint8_t length  {0};
   uint8_t               data[0];
 
+  std::string kind_string() const
+  { return kind_string(static_cast<Kind>(kind)); }
+
   static std::string kind_string(Kind kind) {
     switch(kind) {
     case MSS:
@@ -52,11 +55,20 @@ struct Option {
     case TS:
       return {"Timestamp"};
 
+    case NOP:
+      return {"No-Operation"};
+
+    case END:
+      return {"End of list"};
+
     default:
       return {"Unknown Option"};
     }
   }
 
+  /**
+   * @brief      Maximum Segment Size option [RFC 793]
+   */
   struct opt_mss {
     const uint8_t   kind    {MSS};
     const uint8_t   length  {4};
@@ -80,6 +92,9 @@ struct Option {
 
   } __attribute__((packed));
 
+  /**
+   * @brief      Timestamp option [RFC 7323] p. 11
+   */
   struct opt_ts {
     const uint8_t   kind    {TS};
     const uint8_t   length  {10};
@@ -93,6 +108,32 @@ struct Option {
 
   } __attribute__((packed));
 
+  /**
+   * @brief      An aligned version of a Timestamp option. Includes padding,
+   *             making the ts values on word boundaries.
+   *
+      The following layout is recommended for sending options on
+      non-<SYN> segments to achieve maximum feasible alignment of 32-bit
+      and 64-bit machines.
+
+                   +--------+--------+--------+--------+
+                   |   NOP  |  NOP   |  TSopt |   10   |
+                   +--------+--------+--------+--------+
+                   |          TSval timestamp          |
+                   +--------+--------+--------+--------+
+                   |          TSecr timestamp          |
+                   +--------+--------+--------+--------+
+   */
+  struct opt_ts_align {
+    const uint8_t padding[2] {NOP, NOP};
+    const opt_ts  ts;
+
+    opt_ts_align(const uint32_t val, const uint32_t echo)
+      : ts{val, echo}
+    {}
+
+  } __attribute__((packed));
+
 }; // < struct Option
 
 } // < namespace net

api/net/tcp/packet.hpp

@@ -186,33 +186,73 @@ class Packet : public PacketIP4 {
   inline Byte* tcp_data()
   { return ip_data() + tcp_header_length(); }
 
+  inline const Byte* tcp_data() const
+  { return ip_data() + tcp_header_length(); }
+
   // Length of data in packet when header has been accounted for
   inline uint16_t tcp_data_length() const
   { return ip_data_length() - tcp_header_length(); }
 
   inline bool has_tcp_data() const
   { return tcp_data_length() > 0; }
 
-  template <typename T, typename... Args>
+  /**
+   * @brief      Adds a tcp option.
+   *
+   * @todo       It's probably a better idea to make the option include
+   *             the padding for it to be aligned, and avoid two mem operations
+   *
+   * @tparam     T          TCP Option
+   * @tparam     Padding    padding in bytes to be put infront of the option
+   * @tparam     Args       construction args to option T
+   */
+  template <typename T, int Padding = 0, typename... Args>
   inline void add_tcp_option(Args&&... args) {
     // to avoid headache, options need to be added BEFORE any data.
     assert(!has_tcp_data());
+    struct NOP {
+      uint8_t kind{0x01};
+    };
     // option address
     auto* addr = tcp_options()+tcp_options_length();
-    // emplace the option
-    const auto& opt = *(new (addr) T(args...));
+    // if to use pre padding
+    if(Padding)
+      new (addr) NOP[Padding];
+
+    // emplace the option after pre padding
+    const auto& opt = *(new (addr + Padding) T(args...));
 
     // find number of NOP to pad with
-    const auto nops = opt.length % 4;
+    const auto nops = (opt.length + Padding) % 4;
     if(nops) {
-      struct NOP {
-        uint8_t kind{0x01};
-      };
-      new (addr + opt.length) NOP[nops];
+      new (addr + Padding + opt.length) NOP[nops];
     }
 
     // update offset
-    set_offset(offset() + round_up(opt.length, 4));
+    set_offset(offset() + round_up(opt.length + Padding, 4));
+
+    set_length(); // update
+  }
+
+  /**
+   * @brief      Adds a tcp option aligned.
+   *             Assumes the user knows what he's doing.
+   *
+   * @tparam     T          An aligned TCP option
+   * @tparam     Args       construction args to option T
+   */
+  template <typename T, typename... Args>
+  inline void add_tcp_option_aligned(Args&&... args) {
+    // to avoid headache, options need to be added BEFORE any data.
+    Expects(!has_tcp_data() and sizeof(T) % 4 == 0);
+
+    // option address
+    auto* addr = tcp_options()+tcp_options_length();
+    // emplace the option
+    new (addr) T(args...);
+
+    // update offset
+    set_offset(offset() + (sizeof(T) / 4));
 
     set_length(); // update
   }
@@ -228,6 +268,9 @@ class Packet : public PacketIP4 {
   inline uint8_t* tcp_options()
   { return (uint8_t*) tcp_header().options; }
 
+  inline const uint8_t* tcp_options() const
+  { return (const uint8_t*) tcp_header().options; }
+
   inline uint8_t tcp_options_length() const
   { return tcp_header_length() - sizeof(Header); }