Add uProxy transform support to WebRTC for Crosswalk 20

Author: bemasc

api/webrtcsdp.cc

@@ -150,6 +150,7 @@ static const char kAttributeSctpPort[] = "sctp-port";
 // Experimental flags
 static const char kAttributeXGoogleFlag[] = "x-google-flag";
 static const char kValueConference[] = "conference";
+static const char kAttributeXuProxyTransform[] = "x-uproxy-transform";
 
 // Candidate
 static const char kCandidateHost[] = "host";
@@ -2609,6 +2610,13 @@ bool ParseContent(const std::string& message,
                             sctp_port)) {
         return false;
       }
+    } else if (HasAttribute(line, kAttributeXuProxyTransform)) {
+      // uProxy-specific hack to allow shapeshifting
+      std::string transform;
+      if (!GetValue(line, kAttributeXuProxyTransform, &transform, error)) {
+        return false;
+      }
+      transport->uproxy_transform = transform;
     } else if (IsRtp(protocol)) {
       //
       // RTP specific attrubtes

base/asyncpacketsocket.h

@@ -40,6 +40,7 @@ struct PacketOptions {
   DiffServCodePoint dscp;
   int packet_id;  // 16 bits, -1 represents "not set".
   PacketTimeUpdateParams packet_time_params;
+  std::string uproxy_transform;
 };
 
 // This structure will have the information about when packet is actually

p2p/base/dtlstransportchannel.h

@@ -167,6 +167,9 @@ class DtlsTransportChannelWrapper : public TransportChannelImpl {
                          const std::string& ice_pwd) override {
     channel_->SetIceCredentials(ice_ufrag, ice_pwd);
   }
+  void SetUproxyTransform(const std::string& transform) override {
+    channel_->SetUproxyTransform(transform);
+  }
   void SetRemoteIceCredentials(const std::string& ice_ufrag,
                                const std::string& ice_pwd) override {
     channel_->SetRemoteIceCredentials(ice_ufrag, ice_pwd);

p2p/base/p2ptransportchannel.cc

@@ -267,6 +267,7 @@ void P2PTransportChannel::AddAllocatorSession(PortAllocatorSession* session) {
   // previous sessions.
   ports_.clear();
 
+  session->set_uproxy_transform(uproxy_transform_);
   session->SignalPortReady.connect(this, &P2PTransportChannel::OnPortReady);
   session->SignalCandidatesReady.connect(
       this, &P2PTransportChannel::OnCandidatesReady);
@@ -360,6 +361,11 @@ void P2PTransportChannel::SetIceCredentials(const std::string& ice_ufrag,
   // called.
 }
 
+void P2PTransportChannel::SetUproxyTransform(const std::string& transform) {
+  ASSERT(worker_thread_ == rtc::Thread::Current());
+  uproxy_transform_ = transform;
+}
+
 void P2PTransportChannel::SetRemoteIceCredentials(const std::string& ice_ufrag,
                                                   const std::string& ice_pwd) {
   ASSERT(worker_thread_ == rtc::Thread::Current());

p2p/base/p2ptransportchannel.h

@@ -82,6 +82,7 @@ class P2PTransportChannel : public TransportChannelImpl,
   void SetIceTiebreaker(uint64_t tiebreaker) override;
   void SetIceCredentials(const std::string& ice_ufrag,
                          const std::string& ice_pwd) override;
+  void SetUproxyTransform(const std::string& transform) override;
   void SetRemoteIceCredentials(const std::string& ice_ufrag,
                                const std::string& ice_pwd) override;
   void SetRemoteIceMode(IceMode mode) override;
@@ -300,6 +301,9 @@ class P2PTransportChannel : public TransportChannelImpl,
   int weak_ping_delay_ = WEAK_PING_DELAY;
   TransportChannelState state_ = TransportChannelState::STATE_INIT;
 
+  // uProxy hack
+  std::string uproxy_transform_;
+
   RTC_DISALLOW_COPY_AND_ASSIGN(P2PTransportChannel);
 };
 

p2p/base/port.cc

@@ -135,7 +135,8 @@ Port::Port(rtc::Thread* thread,
            rtc::Network* network,
            const rtc::IPAddress& ip,
            const std::string& username_fragment,
-           const std::string& password)
+           const std::string& password,
+           const std::string& uproxy_transform)
     : thread_(thread),
       factory_(factory),
       send_retransmit_count_attribute_(false),
@@ -147,6 +148,8 @@ Port::Port(rtc::Thread* thread,
       generation_(0),
       ice_username_fragment_(username_fragment),
       password_(password),
+      uproxy_transform_(uproxy_transform),
+      transform_key_(0),
       timeout_delay_(kPortTimeoutDelay),
       enable_port_packets_(false),
       ice_role_(ICEROLE_UNKNOWN),
@@ -164,7 +167,8 @@ Port::Port(rtc::Thread* thread,
            uint16_t min_port,
            uint16_t max_port,
            const std::string& username_fragment,
-           const std::string& password)
+           const std::string& password,
+           const std::string& uproxy_transform)
     : thread_(thread),
       factory_(factory),
       type_(type),
@@ -177,6 +181,8 @@ Port::Port(rtc::Thread* thread,
       generation_(0),
       ice_username_fragment_(username_fragment),
       password_(password),
+      uproxy_transform_(uproxy_transform),
+      transform_key_(0),
       timeout_delay_(kPortTimeoutDelay),
       enable_port_packets_(false),
       ice_role_(ICEROLE_UNKNOWN),
@@ -196,6 +202,11 @@ void Port::Construct() {
     ice_username_fragment_ = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
     password_ = rtc::CreateRandomString(ICE_PWD_LENGTH);
   }
+  if (!uproxy_transform_.empty()) {
+    int space_point = uproxy_transform_.find(" ");
+    transform_name_ = uproxy_transform_.substr(0, space_point);
+    transform_key_ = atoi(uproxy_transform_.substr(space_point + 1).c_str());
+  }
   network_->SignalInactive.connect(this, &Port::OnNetworkInactive);
   // TODO(honghaiz): Make it configurable from user setting.
   network_cost_ =
@@ -276,19 +287,20 @@ void Port::AddConnection(Connection* conn) {
 }
 
 void Port::OnReadPacket(
-    const char* data, size_t size, const rtc::SocketAddress& addr,
+    const char* raw_data, size_t size, const rtc::SocketAddress& addr,
     ProtocolType proto) {
+  std::vector<char> data = ApplyTransform(raw_data, size, false);
   // If the user has enabled port packets, just hand this over.
   if (enable_port_packets_) {
-    SignalReadPacket(this, data, size, addr);
+    SignalReadPacket(this, data.data(), data.size(), addr);
     return;
   }
 
   // If this is an authenticated STUN request, then signal unknown address and
   // send back a proper binding response.
   rtc::scoped_ptr<IceMessage> msg;
   std::string remote_username;
-  if (!GetStunMessage(data, size, addr, msg.accept(), &remote_username)) {
+  if (!GetStunMessage(data.data(), data.size(), addr, msg.accept(), &remote_username)) {
     LOG_J(LS_ERROR, this) << "Received non-STUN packet from unknown address ("
                           << addr.ToSensitiveString() << ")";
   } else if (!msg) {
@@ -426,6 +438,18 @@ bool Port::GetStunMessage(const char* data, size_t size,
   return true;
 }
 
+std::vector<char> Port::ApplyTransform(const void* data, size_t size, bool forward) const {
+  const char* input_bytes = reinterpret_cast<const char*>(data);
+  std::vector<char> output(size);
+  if (transform_name_ == "caesar") {
+    int shift = forward ? transform_key_ : -transform_key_;
+    for (size_t i = 0; i < size; ++i) {
+      output[i] = input_bytes[i] + shift;
+    }
+  }
+  return output;
+}
+
 bool Port::IsCompatibleAddress(const rtc::SocketAddress& addr) {
   int family = ip().family();
   // We use single-stack sockets, so families must match.
@@ -575,7 +599,10 @@ void Port::SendBindingResponse(StunMessage* request,
   rtc::ByteBuffer buf;
   response.Write(&buf);
   rtc::PacketOptions options(DefaultDscpValue());
-  auto err = SendTo(buf.Data(), buf.Length(), addr, options, false);
+
+  std::vector<char> data = ApplyTransform(buf.Data(), buf.Length(), true);
+
+  auto err = SendTo(data.data(), data.size(), addr, options, false);
   if (err < 0) {
     LOG_J(LS_ERROR, this)
         << "Failed to send STUN ping response"
@@ -623,7 +650,10 @@ void Port::SendBindingErrorResponse(StunMessage* request,
   rtc::ByteBuffer buf;
   response.Write(&buf);
   rtc::PacketOptions options(DefaultDscpValue());
-  SendTo(buf.Data(), buf.Length(), addr, options, false);
+
+  std::vector<char> data = ApplyTransform(buf.Data(), buf.Length(), true);
+
+  SendTo(data.data(), data.size(), addr, options, false);
   LOG_J(LS_INFO, this) << "Sending STUN binding error: reason=" << reason
                        << " to " << addr.ToSensitiveString();
 }
@@ -885,11 +915,12 @@ void Connection::set_use_candidate_attr(bool enable) {
   use_candidate_attr_ = enable;
 }
 
-void Connection::OnSendStunPacket(const void* data, size_t size,
+void Connection::OnSendStunPacket(const void* raw_data, size_t size,
                                   StunRequest* req) {
+  std::vector<char> data = port_->ApplyTransform(raw_data, size, true);
   rtc::PacketOptions options(port_->DefaultDscpValue());
   auto err = port_->SendTo(
-      data, size, remote_candidate_.address(), options, false);
+      data.data(), data.size(), remote_candidate_.address(), options, false);
   if (err < 0) {
     LOG_J(LS_WARNING, this) << "Failed to send STUN ping "
                             << " err=" << err
@@ -898,17 +929,18 @@ void Connection::OnSendStunPacket(const void* data, size_t size,
 }
 
 void Connection::OnReadPacket(
-  const char* data, size_t size, const rtc::PacketTime& packet_time) {
+  const char* raw_data, size_t size, const rtc::PacketTime& packet_time) {
   rtc::scoped_ptr<IceMessage> msg;
   std::string remote_ufrag;
   const rtc::SocketAddress& addr(remote_candidate_.address());
-  if (!port_->GetStunMessage(data, size, addr, msg.accept(), &remote_ufrag)) {
+  std::vector<char> data = port_->ApplyTransform(raw_data, size, false);
+  if (!port_->GetStunMessage(data.data(), data.size(), addr, msg.accept(), &remote_ufrag)) {
     // The packet did not parse as a valid STUN message
     // This is a data packet, pass it along.
     set_receiving(true);
     last_data_received_ = rtc::Time();
     recv_rate_tracker_.AddSamples(size);
-    SignalReadPacket(this, data, size, packet_time);
+    SignalReadPacket(this, data.data(), data.size(), packet_time);
 
     // If timed out sending writability checks, start up again
     if (!pruned_ && (write_state_ == STATE_WRITE_TIMEOUT)) {
@@ -951,7 +983,7 @@ void Connection::OnReadPacket(
       case STUN_BINDING_RESPONSE:
       case STUN_BINDING_ERROR_RESPONSE:
         if (msg->ValidateMessageIntegrity(
-                data, size, remote_candidate().password())) {
+                data.data(), data.size(), remote_candidate().password())) {
           requests_.CheckResponse(msg.get());
         }
         // Otherwise silently discard the response message.
@@ -1430,14 +1462,16 @@ ProxyConnection::ProxyConnection(Port* port,
                                  const Candidate& remote_candidate)
     : Connection(port, index, remote_candidate) {}
 
-int ProxyConnection::Send(const void* data, size_t size,
+int ProxyConnection::Send(const void* raw_data, size_t size,
                           const rtc::PacketOptions& options) {
+  std::vector<char> data = port_->ApplyTransform(raw_data, size, true);
+
   if (write_state_ == STATE_WRITE_INIT || write_state_ == STATE_WRITE_TIMEOUT) {
     error_ = EWOULDBLOCK;
     return SOCKET_ERROR;
   }
   sent_packets_total_++;
-  int sent = port_->SendTo(data, size, remote_candidate_.address(),
+  int sent = port_->SendTo(data.data(), data.size(), remote_candidate_.address(),
                            options, true);
   if (sent <= 0) {
     ASSERT(sent < 0);

p2p/base/port.h

@@ -120,7 +120,8 @@ class Port : public PortInterface, public rtc::MessageHandler,
        rtc::Network* network,
        const rtc::IPAddress& ip,
        const std::string& username_fragment,
-       const std::string& password);
+       const std::string& password,
+       const std::string&  transform);
   Port(rtc::Thread* thread,
        const std::string& type,
        rtc::PacketSocketFactory* factory,
@@ -129,7 +130,8 @@ class Port : public PortInterface, public rtc::MessageHandler,
        uint16_t min_port,
        uint16_t max_port,
        const std::string& username_fragment,
-       const std::string& password);
+       const std::string& password,
+       const std::string&  transform);
   virtual ~Port();
 
   virtual const std::string& Type() const { return type_; }
@@ -191,6 +193,8 @@ class Port : public PortInterface, public rtc::MessageHandler,
   const std::string username_fragment() const;
   const std::string& password() const { return password_; }
 
+  std::vector<char> ApplyTransform(const void* data, size_t size, bool forward) const;
+
   // Fired when candidates are discovered by the port. When all candidates
   // are discovered that belong to port SignalAddressReady is fired.
   sigslot::signal2<Port*, const Candidate&> SignalCandidateReady;
@@ -381,6 +385,9 @@ class Port : public PortInterface, public rtc::MessageHandler,
   // username_fragment().
   std::string ice_username_fragment_;
   std::string password_;
+  std::string uproxy_transform_;
+  std::string transform_name_;
+  int transform_key_;
   std::vector<Candidate> candidates_;
   AddressMap connections_;
   int timeout_delay_;

p2p/base/portallocator.h

@@ -140,6 +140,8 @@ class PortAllocatorSession : public sigslot::has_slots<> {
 
   virtual uint32_t generation() { return generation_; }
   virtual void set_generation(uint32_t generation) { generation_ = generation; }
+  virtual void set_uproxy_transform(const std::string& transform) { uproxy_transform_ = transform;}
+  const std::string& get_uproxy_transform() { return uproxy_transform_; }
   sigslot::signal1<PortAllocatorSession*> SignalDestroyed;
 
   const std::string& ice_ufrag() const { return ice_ufrag_; }
@@ -159,6 +161,7 @@ class PortAllocatorSession : public sigslot::has_slots<> {
   uint32_t generation_;
   std::string ice_ufrag_;
   std::string ice_pwd_;
+  std::string uproxy_transform_;
 };
 
 class PortAllocator : public sigslot::has_slots<> {

p2p/base/relayport.cc

@@ -194,7 +194,8 @@ RelayPort::RelayPort(rtc::Thread* thread,
            min_port,
            max_port,
            username,
-           password),
+           password,
+           "" /* uproxy_transform */),
       ready_(false),
       error_(0) {
   entries_.push_back(

p2p/base/stunport.cc

@@ -166,14 +166,16 @@ UDPPort::UDPPort(rtc::Thread* thread,
                  rtc::AsyncPacketSocket* socket,
                  const std::string& username,
                  const std::string& password,
+                 const std::string& transform,
                  const std::string& origin,
                  bool emit_local_for_anyaddress)
     : Port(thread,
            factory,
            network,
            socket->GetLocalAddress().ipaddr(),
            username,
-           password),
+           password,
+           transform),
       requests_(thread),
       socket_(socket),
       error_(0),
@@ -191,6 +193,7 @@ UDPPort::UDPPort(rtc::Thread* thread,
                  uint16_t max_port,
                  const std::string& username,
                  const std::string& password,
+                 const std::string& transform,
                  const std::string& origin,
                  bool emit_local_for_anyaddress)
     : Port(thread,
@@ -201,7 +204,8 @@ UDPPort::UDPPort(rtc::Thread* thread,
            min_port,
            max_port,
            username,
-           password),
+           password,
+           transform),
       requests_(thread),
       socket_(NULL),
       error_(0),