media/mtransport/test/sctp_unittest.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 // Original author: ekr@rtfm.com
   8
   9 #include <iostream>
  10 #include <string>
  11 #include <map>
  12
  13 #include "sigslot.h"
  14
  15 #include "logging.h"
  16 #include "nsNetCID.h"
  17 #include "nsITimer.h"
  18 #include "nsComponentManagerUtils.h"
  19 #include "nsThreadUtils.h"
  20 #include "nsXPCOM.h"
  21
  22 #include "transportflow.h"
  23 #include "transportlayer.h"
  24 #include "transportlayerloopback.h"
  25
  26 #include "mtransport_test_utils.h"
  27 #include "runnable_utils.h"
  28 #include "usrsctp.h"
  29
  30 #define GTEST_HAS_RTTI 0
  31 #include "gtest/gtest.h"
  32 #include "gtest_utils.h"
  33
  34
  35 using namespace mozilla;
  36
  37 MtransportTestUtils *test_utils;
  38 static bool sctp_logging = false;
  39 static int port_number = 5000;
  40
  41 namespace {
  42
  43 class TransportTestPeer;
  44
  45 class SendPeriodic : public nsITimerCallback {
  46  public:
  47   SendPeriodic(TransportTestPeer *peer, int to_send) :
  48       peer_(peer),
  49       to_send_(to_send) {}
  50
  51   NS_DECL_THREADSAFE_ISUPPORTS
  52   NS_DECL_NSITIMERCALLBACK
  53
  54  protected:
  55   virtual ~SendPeriodic() {}
  56
  57   TransportTestPeer *peer_;
  58   int to_send_;
  59 };
  60
  61 NS_IMPL_ISUPPORTS(SendPeriodic, nsITimerCallback)
  62
  63
  64 class TransportTestPeer : public sigslot::has_slots<> {
  65  public:
  66   TransportTestPeer(std::string name, int local_port, int remote_port)
  67       : name_(name), connected_(false),
  68         sent_(0), received_(0),
  69         flow_(new TransportFlow()),
  70         loopback_(new TransportLayerLoopback()),
  71         sctp_(usrsctp_socket(AF_CONN, SOCK_STREAM, IPPROTO_SCTP, receive_cb, nullptr, 0, nullptr)),
  72         timer_(do_CreateInstance(NS_TIMER_CONTRACTID)),
  73         periodic_(nullptr) {
  74     std::cerr << "Creating TransportTestPeer; flow=" <<
  75         static_cast<void *>(flow_.get()) <<
  76         " local=" << local_port <<
  77         " remote=" << remote_port << std::endl;
  78
  79     usrsctp_register_address(static_cast<void *>(this));
  80     int r = usrsctp_set_non_blocking(sctp_, 1);
  81     EXPECT_GE(r, 0);
  82
  83     struct linger l;
  84     l.l_onoff = 1;
  85     l.l_linger = 0;
  86     r = usrsctp_setsockopt(sctp_, SOL_SOCKET, SO_LINGER, &l,
  87                        (socklen_t)sizeof(l));
  88     EXPECT_GE(r, 0);
  89
  90     struct sctp_event subscription;
  91     memset(&subscription, 0, sizeof(subscription));
  92     subscription.se_assoc_id = SCTP_ALL_ASSOC;
  93     subscription.se_on = 1;
  94     subscription.se_type = SCTP_ASSOC_CHANGE;
  95     r = usrsctp_setsockopt(sctp_, IPPROTO_SCTP, SCTP_EVENT, &subscription,
  96                            sizeof(subscription));
  97     EXPECT_GE(r, 0);
  98
  99     memset(&local_addr_, 0, sizeof(local_addr_));
 100     local_addr_.sconn_family = AF_CONN;
 101 #if !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows) && !defined(__Userspace_os_Android)
 102     local_addr_.sconn_len = sizeof(struct sockaddr_conn);
 103 #endif
 104     local_addr_.sconn_port = htons(local_port);
 105     local_addr_.sconn_addr = static_cast<void *>(this);
 106
 107
 108     memset(&remote_addr_, 0, sizeof(remote_addr_));
 109     remote_addr_.sconn_family = AF_CONN;
 110 #if !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows) && !defined(__Userspace_os_Android)
 111     remote_addr_.sconn_len = sizeof(struct sockaddr_conn);
 112 #endif
 113     remote_addr_.sconn_port = htons(remote_port);
 114     remote_addr_.sconn_addr = static_cast<void *>(this);
 115
 116     nsresult res;
 117     res = loopback_->Init();
 118     EXPECT_EQ((nsresult)NS_OK, res);
 119   }
 120
 121   ~TransportTestPeer() {
 122     std::cerr << "Destroying sctp connection flow=" <<
 123         static_cast<void *>(flow_.get()) << std::endl;
 124     usrsctp_close(sctp_);
 125     usrsctp_deregister_address(static_cast<void *>(this));
 126
 127     test_utils->sts_target()->Dispatch(WrapRunnable(this,
 128                                                    &TransportTestPeer::Disconnect_s),
 129                                       NS_DISPATCH_SYNC);
 130
 131     std::cerr << "~TransportTestPeer() completed" << std::endl;
 132   }
 133
 134   void ConnectSocket(TransportTestPeer *peer) {
 135     test_utils->sts_target()->Dispatch(WrapRunnable(
 136         this, &TransportTestPeer::ConnectSocket_s, peer),
 137                                        NS_DISPATCH_SYNC);
 138   }
 139
 140   void ConnectSocket_s(TransportTestPeer *peer) {
 141     loopback_->Connect(peer->loopback_);
 142
 143     ASSERT_EQ((nsresult)NS_OK, flow_->PushLayer(loopback_));
 144
 145     flow_->SignalPacketReceived.connect(this, &TransportTestPeer::PacketReceived);
 146
 147     // SCTP here!
 148     ASSERT_TRUE(sctp_);
 149     std::cerr << "Calling usrsctp_bind()" << std::endl;
 150     int r = usrsctp_bind(sctp_, reinterpret_cast<struct sockaddr *>(
 151         &local_addr_), sizeof(local_addr_));
 152     ASSERT_GE(0, r);
 153
 154     std::cerr << "Calling usrsctp_connect()" << std::endl;
 155     r = usrsctp_connect(sctp_, reinterpret_cast<struct sockaddr *>(
 156         &remote_addr_), sizeof(remote_addr_));
 157     ASSERT_GE(0, r);
 158   }
 159
 160   void Disconnect_s() {
 161     if (flow_) {
 162       flow_ = nullptr;
 163     }
 164   }
 165
 166   void Disconnect() {
 167     loopback_->Disconnect();
 168   }
 169
 170
 171   void StartTransfer(size_t to_send) {
 172     periodic_ = new SendPeriodic(this, to_send);
 173     timer_->SetTarget(test_utils->sts_target());
 174     timer_->InitWithCallback(periodic_, 10, nsITimer::TYPE_REPEATING_SLACK);
 175   }
 176
 177   void SendOne() {
 178     unsigned char buf[100];
 179     memset(buf, sent_ & 0xff, sizeof(buf));
 180
 181     struct sctp_sndinfo info;
 182     info.snd_sid = 1;
 183     info.snd_flags = 0;
 184     info.snd_ppid = 50;  // What the heck is this?
 185     info.snd_context = 0;
 186     info.snd_assoc_id = 0;
 187
 188     int r = usrsctp_sendv(sctp_, buf, sizeof(buf), nullptr, 0,
 189                           static_cast<void *>(&info),
 190                           sizeof(info), SCTP_SENDV_SNDINFO, 0);
 191     ASSERT_TRUE(r >= 0);
 192     ASSERT_EQ(sizeof(buf), (size_t)r);
 193
 194     ++sent_;
 195   }
 196
 197   int sent() const { return sent_; }
 198   int received() const { return received_; }
 199   bool connected() const { return connected_; }
 200
 201   static TransportResult SendPacket_s(const unsigned char* data, size_t len,
 202                                       const mozilla::RefPtr<TransportFlow>& flow) {
 203     TransportResult res = flow->SendPacket(data, len);
 204     delete data; // we always allocate
 205     return res;
 206   }
 207
 208   TransportResult SendPacket(const unsigned char* data, size_t len) {
 209     unsigned char *buffer = new unsigned char[len];
 210     memcpy(buffer, data, len);
 211
 212     // Uses DISPATCH_NORMAL to avoid possible deadlocks when we're called
 213     // from MainThread especially during shutdown (same as DataChannels).
 214     // RUN_ON_THREAD short-circuits if already on the STS thread, which is
 215     // normal for most transfers outside of connect() and close().  Passes
 216     // a refptr to flow_ to avoid any async deletion issues (since we can't
 217     // make 'this' into a refptr as it isn't refcounted)
 218     RUN_ON_THREAD(test_utils->sts_target(), WrapRunnableNM(
 219         &TransportTestPeer::SendPacket_s, buffer, len, flow_),
 220                   NS_DISPATCH_NORMAL);
 221
 222     return 0;
 223   }
 224
 225   void PacketReceived(TransportFlow * flow, const unsigned char* data,
 226                       size_t len) {
 227     std::cerr << "Received " << len << " bytes" << std::endl;
 228
 229     // Pass the data to SCTP
 230
 231     usrsctp_conninput(static_cast<void *>(this), data, len, 0);
 232   }
 233
 234   // Process SCTP notification
 235   void Notification(union sctp_notification *msg, size_t len) {
 236     ASSERT_EQ(msg->sn_header.sn_length, len);
 237
 238     if (msg->sn_header.sn_type == SCTP_ASSOC_CHANGE) {
 239       struct sctp_assoc_change *change = &msg->sn_assoc_change;
 240
 241       if (change->sac_state == SCTP_COMM_UP) {
 242         std::cerr << "Connection up" << std::endl;
 243         SetConnected(true);
 244       } else {
 245         std::cerr << "Connection down" << std::endl;
 246         SetConnected(false);
 247       }
 248     }
 249   }
 250
 251   void SetConnected(bool state) {
 252     connected_ = state;
 253   }
 254
 255   static int conn_output(void *addr, void *buffer, size_t length, uint8_t tos, uint8_t set_df) {
 256     TransportTestPeer *peer = static_cast<TransportTestPeer *>(addr);
 257
 258     peer->SendPacket(static_cast<unsigned char *>(buffer), length);
 259
 260     return 0;
 261   }
 262
 263   static int receive_cb(struct socket* sock, union sctp_sockstore addr,
 264                         void *data, size_t datalen,
 265                         struct sctp_rcvinfo rcv, int flags, void *ulp_info) {
 266     TransportTestPeer *me = static_cast<TransportTestPeer *>(
 267         addr.sconn.sconn_addr);
 268     MOZ_ASSERT(me);
 269
 270     if (flags & MSG_NOTIFICATION) {
 271       union sctp_notification *notif =
 272           static_cast<union sctp_notification *>(data);
 273
 274       me->Notification(notif, datalen);
 275       return 0;
 276     }
 277
 278     me->received_ += datalen;
 279
 280     std::cerr << "receive_cb: sock " << sock << " data " << data << "(" << datalen << ") total received bytes = " << me->received_ << std::endl;
 281
 282     return 0;
 283   }
 284
 285
 286  private:
 287   std::string name_;
 288   bool connected_;
 289   size_t sent_;
 290   size_t received_;
 291   mozilla::RefPtr<TransportFlow> flow_;
 292   TransportLayerLoopback *loopback_;
 293
 294   struct sockaddr_conn local_addr_;
 295   struct sockaddr_conn remote_addr_;
 296   struct socket *sctp_;
 297   nsCOMPtr<nsITimer> timer_;
 298   nsRefPtr<SendPeriodic> periodic_;
 299 };
 300
 301
 302 // Implemented here because it calls a method of TransportTestPeer
 303 NS_IMETHODIMP SendPeriodic::Notify(nsITimer *timer) {
 304   peer_->SendOne();
 305   --to_send_;
 306   if (!to_send_) {
 307     timer->Cancel();
 308   }
 309   return NS_OK;
 310 }
 311
 312 class TransportTest : public ::testing::Test {
 313  public:
 314   TransportTest() {
 315   }
 316
 317   ~TransportTest() {
 318     if (p1_)
 319       p1_->Disconnect();
 320     if (p2_)
 321       p2_->Disconnect();
 322     delete p1_;
 323     delete p2_;
 324   }
 325
 326   static void debug_printf(const char *format, ...) {
 327     va_list ap;
 328
 329     va_start(ap, format);
 330     vprintf(format, ap);
 331     va_end(ap);
 332   }
 333
 334
 335   static void SetUpTestCase() {
 336     if (sctp_logging) {
 337       usrsctp_init(0, &TransportTestPeer::conn_output, debug_printf);
 338       usrsctp_sysctl_set_sctp_debug_on(0xffffffff);
 339     } else {
 340       usrsctp_init(0, &TransportTestPeer::conn_output, nullptr);
 341     }
 342   }
 343
 344   void SetUp() {
 345   }
 346
 347   void ConnectSocket(int p1port = 0, int p2port = 0) {
 348     if (!p1port)
 349       p1port = port_number++;
 350     if (!p2port)
 351       p2port = port_number++;
 352
 353     p1_ = new TransportTestPeer("P1", p1port, p2port);
 354     p2_ = new TransportTestPeer("P2", p2port, p1port);
 355
 356     p1_->ConnectSocket(p2_);
 357     p2_->ConnectSocket(p1_);
 358     ASSERT_TRUE_WAIT(p1_->connected(), 2000);
 359     ASSERT_TRUE_WAIT(p2_->connected(), 2000);
 360   }
 361
 362   void TestTransfer(int expected = 1) {
 363     std::cerr << "Starting trasnsfer test" << std::endl;
 364     p1_->StartTransfer(expected);
 365     ASSERT_TRUE_WAIT(p1_->sent() == expected, 10000);
 366     ASSERT_TRUE_WAIT(p2_->received() == (expected * 100), 10000);
 367     std::cerr << "P2 received " << p2_->received() << std::endl;
 368   }
 369
 370  protected:
 371   TransportTestPeer *p1_;
 372   TransportTestPeer *p2_;
 373 };
 374
 375 TEST_F(TransportTest, TestConnect) {
 376   ConnectSocket();
 377 }
 378
 379 TEST_F(TransportTest, TestConnectSymmetricalPorts) {
 380   ConnectSocket(5002,5002);
 381 }
 382
 383 TEST_F(TransportTest, TestTransfer) {
 384   ConnectSocket();
 385   TestTransfer(50);
 386 }
 387
 388
 389 }  // end namespace
 390
 391 int main(int argc, char **argv)
 392 {
 393   test_utils = new MtransportTestUtils();
 394   // Start the tests
 395   ::testing::InitGoogleTest(&argc, argv);
 396
 397   for(int i=0; i<argc; i++) {
 398     if (!strcmp(argv[i],"-v")) {
 399       sctp_logging = true;
 400     }
 401   }
 402
 403   int rv = RUN_ALL_TESTS();
 404   delete test_utils;
 405   return rv;
 406 }