Better determination of Symmetric NAT

webrtc/p2p/stunprober/stunprober.h

 /*
  *  Copyright 2015 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.
  */
 
@@ skipping 12 matching lines @@
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/typedefs.h"
 
 namespace stunprober {
 
 static const int kMaxUdpBufferSize = 1200;
 
 typedef rtc::Callback1<void, int> AsyncCallback;
 
+enum NatType {
+  NATTYPE_INVALID,
+  NATTYPE_NONE,          // Not behind a NAT.
+  NATTYPE_UNKNOWN,       // Behind a NAT but type can't be determine.
+  NATTYPE_SYMMETRIC,     // Behind a symmetric NAT.
+  NATTYPE_NON_SYMMETRIC  // Behind a non-symmetric NAT.
+};
+
 class HostNameResolverInterface {
  public:
   HostNameResolverInterface() {}
 
   // Resolve should allow re-entry as |callback| could trigger another
   // Resolve().
   virtual void Resolve(const rtc::SocketAddress& addr,
                        std::vector<rtc::SocketAddress>* addresses,
                        AsyncCallback callback) = 0;
 
@@ skipping 89 matching lines @@
   enum Status {       // Used in UMA_HISTOGRAM_ENUMERATION.
     SUCCESS,          // Successfully received bytes from the server.
     GENERIC_FAILURE,  // Generic failure.
     RESOLVE_FAILED,   // Host resolution failed.
     WRITE_FAILED,     // Sending a message to the server failed.
     READ_FAILED,      // Reading the reply from the server failed.
   };
 
   struct Stats {
     Stats() {}
+
     int num_request_sent = 0;
     int num_response_received = 0;
-    bool behind_nat = false;
-    bool symmetric_nat = false;
+    NatType nat_type = NATTYPE_INVALID;
     int average_rtt_ms = -1;
     int success_percent = 0;
     int target_request_interval_ns = 0;
     int actual_request_interval_ns = 0;
 
     // Also report whether this trial can't be considered truly as shared
     // mode. Share mode only makes sense when we have multiple IP resolved and
     // successfully probed.
     bool shared_socket_mode = false;
 
@@ skipping 25 matching lines @@
   bool Start(const std::vector<rtc::SocketAddress>& servers,
              bool shared_socket_mode,
              int stun_ta_interval_ms,
              int requests_per_ip,
              int timeout_ms,
              const AsyncCallback finish_callback);
 
   // Method to retrieve the Stats once |finish_callback| is invoked. Returning
   // false when the result is inconclusive, for example, whether it's behind a
   // NAT or not.
-  bool GetStats(Stats* stats);
+  bool GetStats(Stats* stats) const;
 
  private:
   // A requester tracks the requests and responses from a single socket to many
   // STUN servers.
   class Requester;
 
   void OnServerResolved(int index, int result);
 
   bool Done() {
     return num_request_sent_ >= requests_per_ip_ * all_servers_ips_.size();
@@ skipping 68 matching lines @@
   std::vector<Requester*> requesters_;
 
   rtc::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(StunProber);
 };
 
 }  // namespace stunprober
 
 #endif  // WEBRTC_P2P_STUNPROBER_STUNPROBER_H_