media/mtransport/nricemediastream.h

   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 // Some of this code is cut-and-pasted from nICEr. Copyright is:
  10
  11 /*
  12 Copyright (c) 2007, Adobe Systems, Incorporated
  13 All rights reserved.
  14
  15 Redistribution and use in source and binary forms, with or without
  16 modification, are permitted provided that the following conditions are
  17 met:
  18
  19 * Redistributions of source code must retain the above copyright
  20   notice, this list of conditions and the following disclaimer.
  21
  22 * Redistributions in binary form must reproduce the above copyright
  23   notice, this list of conditions and the following disclaimer in the
  24   documentation and/or other materials provided with the distribution.
  25
  26 * Neither the name of Adobe Systems, Network Resonance nor the names of its
  27   contributors may be used to endorse or promote products derived from
  28   this software without specific prior written permission.
  29
  30 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  31 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  32 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  33 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  34 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  35 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  36 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  37 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  38 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  39 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  40 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  41 */
  42
  43 // This is a wrapper around the nICEr ICE stack
  44 #ifndef nricemediastream_h__
  45 #define nricemediastream_h__
  46
  47 #include <string>
  48 #include <vector>
  49
  50 #include "sigslot.h"
  51
  52 #include "mozilla/RefPtr.h"
  53 #include "mozilla/Scoped.h"
  54 #include "nsCOMPtr.h"
  55 #include "nsIEventTarget.h"
  56 #include "nsITimer.h"
  57
  58 #include "m_cpp_utils.h"
  59
  60
  61 namespace mozilla {
  62
  63 typedef struct nr_ice_media_stream_ nr_ice_media_stream;
  64
  65 class NrIceCtx;
  66
  67 struct NrIceAddr {
  68   std::string host;
  69   uint16_t port;
  70   std::string transport;
  71 };
  72
  73 /* A summary of a candidate, for use in asking which candidate
  74    pair is active */
  75 struct NrIceCandidate {
  76   enum Type {
  77     ICE_HOST,
  78     ICE_SERVER_REFLEXIVE,
  79     ICE_PEER_REFLEXIVE,
  80     ICE_RELAYED
  81   };
  82
  83   NrIceAddr cand_addr;
  84   NrIceAddr local_addr;
  85   Type type;
  86   std::string codeword;
  87 };
  88
  89 struct NrIceCandidatePair {
  90
  91   enum State {
  92     STATE_FROZEN,
  93     STATE_WAITING,
  94     STATE_IN_PROGRESS,
  95     STATE_FAILED,
  96     STATE_SUCCEEDED,
  97     STATE_CANCELLED
  98   };
  99
 100   State state;
 101   uint64_t priority;
 102   // Set regardless of who nominated it. Does not necessarily mean that it is
 103   // ready to be selected (ie; nominated by peer, but our check has not
 104   // succeeded yet.) Note: since this implementation uses aggressive nomination,
 105   // when we are the controlling agent, this will always be set if the pair is
 106   // in STATE_SUCCEEDED.
 107   bool nominated;
 108   // Set if this candidate pair has been selected. Note: Since we are using
 109   // aggressive nomination, this could change frequently as ICE runs.
 110   bool selected;
 111   NrIceCandidate local;
 112   NrIceCandidate remote;
 113   // TODO(bcampen@mozilla.com): Is it important to put the foundation in here?
 114   std::string codeword;
 115 };
 116
 117 class NrIceMediaStream {
 118  public:
 119   static RefPtr<NrIceMediaStream> Create(NrIceCtx *ctx,
 120                                          const std::string& name,
 121                                          int components);
 122   enum State { ICE_CONNECTING, ICE_OPEN, ICE_CLOSED};
 123
 124   State state() const { return state_; }
 125
 126   // The name of the stream
 127   const std::string& name() const { return name_; }
 128
 129   // Get all the candidates
 130   std::vector<std::string> GetCandidates() const;
 131
 132   nsresult GetLocalCandidates(std::vector<NrIceCandidate>* candidates) const;
 133   nsresult GetRemoteCandidates(std::vector<NrIceCandidate>* candidates) const;
 134
 135   // Get all candidate pairs, whether in the check list or triggered check
 136   // queue, in priority order. |out_pairs| is cleared before being filled.
 137   nsresult GetCandidatePairs(std::vector<NrIceCandidatePair>* out_pairs) const;
 138
 139   // TODO(bug 1096795): This needs to take a component number, so we can get
 140   // default candidates for rtcp.
 141   nsresult GetDefaultCandidate(NrIceCandidate* candidate) const;
 142
 143   // Parse remote attributes
 144   nsresult ParseAttributes(std::vector<std::string>& candidates);
 145   bool HasParsedAttributes() const { return has_parsed_attrs_; }
 146
 147   // Parse trickle ICE candidate
 148   nsresult ParseTrickleCandidate(const std::string& candidate);
 149
 150   // Disable a component
 151   nsresult DisableComponent(int component);
 152
 153   // Get the candidate pair currently active. It's the
 154   // caller's responsibility to free these.
 155   nsresult GetActivePair(int component,
 156                          NrIceCandidate** local, NrIceCandidate** remote);
 157
 158   // The number of components
 159   size_t components() const { return components_; }
 160
 161   // The underlying nICEr stream
 162   nr_ice_media_stream *stream() { return stream_; }
 163   // Signals to indicate events. API users can (and should)
 164   // register for these.
 165
 166   // Send a packet
 167   nsresult SendPacket(int component_id, const unsigned char *data, size_t len);
 168
 169   // Set your state to ready. Called by the NrIceCtx;
 170   void Ready();
 171
 172   // Close the stream. Called by the NrIceCtx.
 173   // Different from the destructor because other people
 174   // might be holding RefPtrs but we want those writes to fail once
 175   // the context has been destroyed.
 176   void Close();
 177
 178   // So the receiver of SignalCandidate can determine which level
 179   // (ie; m-line index) the candidate belongs to.
 180   void SetLevel(uint16_t level) { level_ = level; }
 181
 182   uint16_t GetLevel() const { return level_; }
 183
 184   sigslot::signal2<NrIceMediaStream *, const std::string& >
 185   SignalCandidate;  // A new ICE candidate:
 186
 187   sigslot::signal1<NrIceMediaStream *> SignalReady;  // Candidate pair ready.
 188   sigslot::signal1<NrIceMediaStream *> SignalFailed;  // Candidate pair failed.
 189   sigslot::signal4<NrIceMediaStream *, int, const unsigned char *, int>
 190   SignalPacketReceived;  // Incoming packet
 191
 192   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(NrIceMediaStream)
 193
 194  private:
 195   NrIceMediaStream(NrIceCtx *ctx,  const std::string& name,
 196                    size_t components) :
 197       state_(ICE_CONNECTING),
 198       ctx_(ctx),
 199       name_(name),
 200       components_(components),
 201       stream_(nullptr),
 202       level_(0),
 203       has_parsed_attrs_(false) {}
 204
 205   ~NrIceMediaStream();
 206
 207   DISALLOW_COPY_ASSIGN(NrIceMediaStream);
 208
 209   State state_;
 210   NrIceCtx *ctx_;
 211   const std::string name_;
 212   const size_t components_;
 213   nr_ice_media_stream *stream_;
 214   uint16_t level_;
 215   bool has_parsed_attrs_;
 216 };
 217
 218
 219 }  // close namespace
 220 #endif