/* -*- mode: c++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this file, * You can obtain one at http://mozilla.org/MPL/2.0/. */ // Original author: ekr@rtfm.com // Some of this code is cut-and-pasted from nICEr. Copyright is: /* Copyright (c) 2007, Adobe Systems, Incorporated All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Adobe Systems, Network Resonance nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include "mozilla/UniquePtr.h" #include "logging.h" #include "nspr.h" #include "nss.h" #include "pk11pub.h" #include "plbase64.h" #include "nsCOMPtr.h" #include "nsComponentManagerUtils.h" #include "nsError.h" #include "nsIEventTarget.h" #include "nsNetCID.h" #include "nsComponentManagerUtils.h" #include "nsServiceManagerUtils.h" #include "ScopedNSSTypes.h" #include "runnable_utils.h" #include "nsIPrefService.h" #include "nsIPrefBranch.h" // nICEr includes extern "C" { #include "nr_api.h" #include "registry.h" #include "async_timer.h" #include "r_crc32.h" #include "r_memory.h" #include "ice_reg.h" #include "ice_util.h" #include "transport_addr.h" #include "nr_crypto.h" #include "nr_socket.h" #include "nr_socket_local.h" #include "nr_proxy_tunnel.h" #include "stun_client_ctx.h" #include "stun_reg.h" #include "stun_server_ctx.h" #include "ice_codeword.h" #include "ice_ctx.h" #include "ice_candidate.h" #include "ice_handler.h" } // Local includes #include "nricectx.h" #include "nricemediastream.h" #include "nr_socket_prsock.h" #include "nrinterfaceprioritizer.h" #include "rlogringbuffer.h" namespace mozilla { TimeStamp nr_socket_short_term_violation_time() { return NrSocketBase::short_term_violation_time(); } TimeStamp nr_socket_long_term_violation_time() { return NrSocketBase::long_term_violation_time(); } MOZ_MTLOG_MODULE("mtransport") const char kNrIceTransportUdp[] = "udp"; const char kNrIceTransportTcp[] = "tcp"; static bool initialized = false; // Implement NSPR-based crypto algorithms static int nr_crypto_nss_random_bytes(UCHAR *buf, int len) { ScopedPK11SlotInfo slot(PK11_GetInternalSlot()); if (!slot) return R_INTERNAL; SECStatus rv = PK11_GenerateRandomOnSlot(slot, buf, len); if (rv != SECSuccess) return R_INTERNAL; return 0; } static int nr_crypto_nss_hmac(UCHAR *key, int keyl, UCHAR *buf, int bufl, UCHAR *result) { CK_MECHANISM_TYPE mech = CKM_SHA_1_HMAC; PK11SlotInfo *slot = 0; MOZ_ASSERT(keyl > 0); SECItem keyi = { siBuffer, key, static_cast(keyl)}; PK11SymKey *skey = 0; PK11Context *hmac_ctx = 0; SECStatus status; unsigned int hmac_len; SECItem param = { siBuffer, nullptr, 0 }; int err = R_INTERNAL; slot = PK11_GetInternalKeySlot(); if (!slot) goto abort; skey = PK11_ImportSymKey(slot, mech, PK11_OriginUnwrap, CKA_SIGN, &keyi, nullptr); if (!skey) goto abort; hmac_ctx = PK11_CreateContextBySymKey(mech, CKA_SIGN, skey, ¶m); if (!hmac_ctx) goto abort; status = PK11_DigestBegin(hmac_ctx); if (status != SECSuccess) goto abort; status = PK11_DigestOp(hmac_ctx, buf, bufl); if (status != SECSuccess) goto abort; status = PK11_DigestFinal(hmac_ctx, result, &hmac_len, 20); if (status != SECSuccess) goto abort; MOZ_ASSERT(hmac_len == 20); err = 0; abort: if(hmac_ctx) PK11_DestroyContext(hmac_ctx, PR_TRUE); if (skey) PK11_FreeSymKey(skey); if (slot) PK11_FreeSlot(slot); return err; } static int nr_crypto_nss_md5(UCHAR *buf, int bufl, UCHAR *result) { int err = R_INTERNAL; SECStatus rv; const SECHashObject *ho = HASH_GetHashObject(HASH_AlgMD5); MOZ_ASSERT(ho); if (!ho) goto abort; MOZ_ASSERT(ho->length == 16); rv = HASH_HashBuf(ho->type, result, buf, bufl); if (rv != SECSuccess) goto abort; err = 0; abort: return err; } static nr_ice_crypto_vtbl nr_ice_crypto_nss_vtbl = { nr_crypto_nss_random_bytes, nr_crypto_nss_hmac, nr_crypto_nss_md5 }; nsresult NrIceStunServer::ToNicerStunStruct(nr_ice_stun_server *server) const { int r; memset(server, 0, sizeof(nr_ice_stun_server)); if (transport_ == kNrIceTransportUdp) { server->transport = IPPROTO_UDP; } else if (transport_ == kNrIceTransportTcp) { server->transport = IPPROTO_TCP; } else { MOZ_ASSERT(false); return NS_ERROR_FAILURE; } if (has_addr_) { r = nr_praddr_to_transport_addr(&addr_, &server->u.addr, server->transport, 0); if (r) { return NS_ERROR_FAILURE; } server->type=NR_ICE_STUN_SERVER_TYPE_ADDR; } else { MOZ_ASSERT(sizeof(server->u.dnsname.host) > host_.size()); PL_strncpyz(server->u.dnsname.host, host_.c_str(), sizeof(server->u.dnsname.host)); server->u.dnsname.port = port_; server->type=NR_ICE_STUN_SERVER_TYPE_DNSNAME; } return NS_OK; } nsresult NrIceTurnServer::ToNicerTurnStruct(nr_ice_turn_server *server) const { memset(server, 0, sizeof(nr_ice_turn_server)); nsresult rv = ToNicerStunStruct(&server->turn_server); if (NS_FAILED(rv)) return rv; if (username_.empty()) return NS_ERROR_INVALID_ARG; if (password_.empty()) return NS_ERROR_INVALID_ARG; if (!(server->username=r_strdup(username_.c_str()))) return NS_ERROR_OUT_OF_MEMORY; // TODO(ekr@rtfm.com): handle non-ASCII passwords somehow? // STUN requires they be SASLpreped, but we don't know if // they are at this point. // C++03 23.2.4, Paragraph 1 stipulates that the elements // in std::vector must be contiguous, and can therefore be // used as input to functions expecting C arrays. int r = r_data_create(&server->password, const_cast(&password_[0]), password_.size()); if (r) { RFREE(server->username); return NS_ERROR_OUT_OF_MEMORY; } return NS_OK; } // Handler callbacks int NrIceCtx::select_pair(void *obj,nr_ice_media_stream *stream, int component_id, nr_ice_cand_pair **potentials, int potential_ct) { MOZ_MTLOG(ML_DEBUG, "select pair called: potential_ct = " << potential_ct); return 0; } int NrIceCtx::stream_ready(void *obj, nr_ice_media_stream *stream) { MOZ_MTLOG(ML_DEBUG, "stream_ready called"); // Get the ICE ctx. NrIceCtx *ctx = static_cast(obj); RefPtr s = ctx->FindStream(stream); // Streams which do not exist should never be ready. MOZ_ASSERT(s); s->Ready(); return 0; } int NrIceCtx::stream_failed(void *obj, nr_ice_media_stream *stream) { MOZ_MTLOG(ML_DEBUG, "stream_failed called"); // Get the ICE ctx NrIceCtx *ctx = static_cast(obj); RefPtr s = ctx->FindStream(stream); // Streams which do not exist should never fail. MOZ_ASSERT(s); ctx->SetConnectionState(ICE_CTX_FAILED); s -> SignalFailed(s); return 0; } int NrIceCtx::ice_checking(void *obj, nr_ice_peer_ctx *pctx) { MOZ_MTLOG(ML_DEBUG, "ice_checking called"); // Get the ICE ctx NrIceCtx *ctx = static_cast(obj); ctx->SetConnectionState(ICE_CTX_CHECKING); return 0; } int NrIceCtx::ice_completed(void *obj, nr_ice_peer_ctx *pctx) { MOZ_MTLOG(ML_DEBUG, "ice_completed called"); // Get the ICE ctx NrIceCtx *ctx = static_cast(obj); // This is called even on failed contexts. if (ctx->connection_state() != ICE_CTX_FAILED) { ctx->SetConnectionState(ICE_CTX_OPEN); } return 0; } int NrIceCtx::msg_recvd(void *obj, nr_ice_peer_ctx *pctx, nr_ice_media_stream *stream, int component_id, UCHAR *msg, int len) { // Get the ICE ctx NrIceCtx *ctx = static_cast(obj); RefPtr s = ctx->FindStream(stream); // Streams which do not exist should never have packets. MOZ_ASSERT(s); s->SignalPacketReceived(s, component_id, msg, len); return 0; } void NrIceCtx::trickle_cb(void *arg, nr_ice_ctx *ice_ctx, nr_ice_media_stream *stream, int component_id, nr_ice_candidate *candidate) { // Get the ICE ctx NrIceCtx *ctx = static_cast(arg); RefPtr s = ctx->FindStream(stream); if (!s) { // This stream has been removed because it is inactive return; } // Format the candidate. char candidate_str[NR_ICE_MAX_ATTRIBUTE_SIZE]; int r = nr_ice_format_candidate_attribute(candidate, candidate_str, sizeof(candidate_str)); MOZ_ASSERT(!r); if (r) return; MOZ_MTLOG(ML_INFO, "NrIceCtx(" << ctx->name_ << "): trickling candidate " << candidate_str); s->SignalCandidate(s, candidate_str); } RefPtr NrIceCtx::Create(const std::string& name, bool offerer, bool allow_loopback, bool tcp_enabled, bool allow_link_local, bool hide_non_default, Policy policy) { RefPtr ctx = new NrIceCtx(name, offerer, policy); // Initialize the crypto callbacks and logging stuff if (!initialized) { NR_reg_init(NR_REG_MODE_LOCAL); RLogRingBuffer::CreateInstance(); nr_crypto_vtbl = &nr_ice_crypto_nss_vtbl; initialized = true; // Set the priorites for candidate type preferences. // These numbers come from RFC 5245 S. 4.1.2.2 NR_reg_set_uchar((char *)NR_ICE_REG_PREF_TYPE_SRV_RFLX, 100); NR_reg_set_uchar((char *)NR_ICE_REG_PREF_TYPE_PEER_RFLX, 110); NR_reg_set_uchar((char *)NR_ICE_REG_PREF_TYPE_HOST, 126); NR_reg_set_uchar((char *)NR_ICE_REG_PREF_TYPE_RELAYED, 5); NR_reg_set_uchar((char *)NR_ICE_REG_PREF_TYPE_SRV_RFLX_TCP, 99); NR_reg_set_uchar((char *)NR_ICE_REG_PREF_TYPE_PEER_RFLX_TCP, 109); NR_reg_set_uchar((char *)NR_ICE_REG_PREF_TYPE_HOST_TCP, 125); NR_reg_set_uchar((char *)NR_ICE_REG_PREF_TYPE_RELAYED_TCP, 0); int32_t stun_client_maximum_transmits = 7; int32_t ice_trickle_grace_period = 5000; int32_t ice_tcp_so_sock_count = 3; int32_t ice_tcp_listen_backlog = 10; nsAutoCString force_net_interface; #ifndef MOZILLA_XPCOMRT_API nsresult res; nsCOMPtr prefs = do_GetService("@mozilla.org/preferences-service;1", &res); if (NS_SUCCEEDED(res)) { nsCOMPtr branch = do_QueryInterface(prefs); if (branch) { branch->GetIntPref( "media.peerconnection.ice.stun_client_maximum_transmits", &stun_client_maximum_transmits); branch->GetIntPref( "media.peerconnection.ice.trickle_grace_period", &ice_trickle_grace_period); branch->GetIntPref( "media.peerconnection.ice.tcp_so_sock_count", &ice_tcp_so_sock_count); branch->GetIntPref( "media.peerconnection.ice.tcp_listen_backlog", &ice_tcp_listen_backlog); branch->GetCharPref( "media.peerconnection.ice.force_interface", getter_Copies(force_net_interface)); } } #endif NR_reg_set_uint4((char *)"stun.client.maximum_transmits", stun_client_maximum_transmits); NR_reg_set_uint4((char *)NR_ICE_REG_TRICKLE_GRACE_PERIOD, ice_trickle_grace_period); NR_reg_set_int4((char *)NR_ICE_REG_ICE_TCP_SO_SOCK_COUNT, ice_tcp_so_sock_count); NR_reg_set_int4((char *)NR_ICE_REG_ICE_TCP_LISTEN_BACKLOG, ice_tcp_listen_backlog); NR_reg_set_char((char *)NR_ICE_REG_ICE_TCP_DISABLE, !tcp_enabled); if (allow_loopback) { NR_reg_set_char((char *)NR_STUN_REG_PREF_ALLOW_LOOPBACK_ADDRS, 1); } if (allow_link_local) { NR_reg_set_char((char *)NR_STUN_REG_PREF_ALLOW_LINK_LOCAL_ADDRS, 1); } if (force_net_interface.Length() > 0) { // Stupid cast.... but needed const nsCString& flat = PromiseFlatCString(static_cast(force_net_interface)); NR_reg_set_string((char *)NR_ICE_REG_PREF_FORCE_INTERFACE_NAME, const_cast(flat.get())); } } // Create the ICE context int r; UINT4 flags = offerer ? NR_ICE_CTX_FLAGS_OFFERER: NR_ICE_CTX_FLAGS_ANSWERER; flags |= NR_ICE_CTX_FLAGS_AGGRESSIVE_NOMINATION; if (policy == ICE_POLICY_RELAY) { flags |= NR_ICE_CTX_FLAGS_RELAY_ONLY; } if (hide_non_default) flags |= NR_ICE_CTX_FLAGS_ONLY_DEFAULT_ADDRS; r = nr_ice_ctx_create(const_cast(name.c_str()), flags, &ctx->ctx_); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't create ICE ctx for '" << name << "'"); return nullptr; } nr_interface_prioritizer *prioritizer = CreateInterfacePrioritizer(); if (!prioritizer) { MOZ_MTLOG(LogLevel::Error, "Couldn't create interface prioritizer."); return nullptr; } r = nr_ice_ctx_set_interface_prioritizer(ctx->ctx_, prioritizer); if (r) { MOZ_MTLOG(LogLevel::Error, "Couldn't set interface prioritizer."); return nullptr; } if (ctx->generating_trickle()) { r = nr_ice_ctx_set_trickle_cb(ctx->ctx_, &NrIceCtx::trickle_cb, ctx); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't set trickle cb for '" << name << "'"); return nullptr; } } // Create the handler objects ctx->ice_handler_vtbl_ = new nr_ice_handler_vtbl(); ctx->ice_handler_vtbl_->select_pair = &NrIceCtx::select_pair; ctx->ice_handler_vtbl_->stream_ready = &NrIceCtx::stream_ready; ctx->ice_handler_vtbl_->stream_failed = &NrIceCtx::stream_failed; ctx->ice_handler_vtbl_->ice_completed = &NrIceCtx::ice_completed; ctx->ice_handler_vtbl_->msg_recvd = &NrIceCtx::msg_recvd; ctx->ice_handler_vtbl_->ice_checking = &NrIceCtx::ice_checking; ctx->ice_handler_ = new nr_ice_handler(); ctx->ice_handler_->vtbl = ctx->ice_handler_vtbl_; ctx->ice_handler_->obj = ctx; // Create the peer ctx. Because we do not support parallel forking, we // only have one peer ctx. std::string peer_name = name + ":default"; r = nr_ice_peer_ctx_create(ctx->ctx_, ctx->ice_handler_, const_cast(peer_name.c_str()), &ctx->peer_); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't create ICE peer ctx for '" << name << "'"); return nullptr; } nsresult rv; ctx->sts_target_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); if (!NS_SUCCEEDED(rv)) return nullptr; return ctx; } // ONLY USE THIS FOR TESTING. Will cause totally unpredictable and possibly very // bad effects if ICE is still live. void NrIceCtx::internal_DeinitializeGlobal() { NR_reg_del((char *)"stun"); NR_reg_del((char *)"ice"); RLogRingBuffer::DestroyInstance(); nr_crypto_vtbl = nullptr; initialized = false; } NrIceCtx::~NrIceCtx() { MOZ_MTLOG(ML_DEBUG, "Destroying ICE ctx '" << name_ <<"'"); for (auto stream = streams_.begin(); stream != streams_.end(); stream++) { if (*stream) { (*stream)->Close(); } } nr_ice_peer_ctx_destroy(&peer_); nr_ice_ctx_destroy(&ctx_); delete ice_handler_vtbl_; delete ice_handler_; } RefPtr NrIceCtx::CreateStream(const std::string& name, int components) { return NrIceMediaStream::Create(this, name, components); } void NrIceCtx::SetStream(size_t index, NrIceMediaStream* stream) { if (index >= streams_.size()) { streams_.resize(index + 1); } RefPtr oldStream(streams_[index]); streams_[index] = stream; if (oldStream) { oldStream->Close(); } } std::string NrIceCtx::ufrag() const { return ctx_->ufrag; } std::string NrIceCtx::pwd() const { return ctx_->pwd; } void NrIceCtx::destroy_peer_ctx() { nr_ice_peer_ctx_destroy(&peer_); } nsresult NrIceCtx::SetControlling(Controlling controlling) { peer_->controlling = (controlling == ICE_CONTROLLING)? 1 : 0; MOZ_MTLOG(ML_DEBUG, "ICE ctx " << name_ << " setting controlling to" << controlling); return NS_OK; } NrIceCtx::Controlling NrIceCtx::GetControlling() { return (peer_->controlling) ? ICE_CONTROLLING : ICE_CONTROLLED; } nsresult NrIceCtx::SetPolicy(Policy policy) { policy_ = policy; return NS_OK; } nsresult NrIceCtx::SetStunServers(const std::vector& stun_servers) { if (stun_servers.empty()) return NS_OK; auto servers = MakeUnique(stun_servers.size()); for (size_t i=0; i < stun_servers.size(); ++i) { nsresult rv = stun_servers[i].ToNicerStunStruct(&servers[i]); if (NS_FAILED(rv)) { MOZ_MTLOG(ML_ERROR, "Couldn't set STUN server for '" << name_ << "'"); return NS_ERROR_FAILURE; } } int r = nr_ice_ctx_set_stun_servers(ctx_, servers.get(), stun_servers.size()); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't set STUN server for '" << name_ << "'"); return NS_ERROR_FAILURE; } return NS_OK; } // TODO(ekr@rtfm.com): This is just SetStunServers with s/Stun/Turn // Could we do a template or something? nsresult NrIceCtx::SetTurnServers(const std::vector& turn_servers) { if (turn_servers.empty()) return NS_OK; auto servers = MakeUnique(turn_servers.size()); for (size_t i=0; i < turn_servers.size(); ++i) { nsresult rv = turn_servers[i].ToNicerTurnStruct(&servers[i]); if (NS_FAILED(rv)) { MOZ_MTLOG(ML_ERROR, "Couldn't set TURN server for '" << name_ << "'"); return NS_ERROR_FAILURE; } } int r = nr_ice_ctx_set_turn_servers(ctx_, servers.get(), turn_servers.size()); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't set TURN server for '" << name_ << "'"); return NS_ERROR_FAILURE; } // TODO(ekr@rtfm.com): This leaks the username/password. Need to free that. return NS_OK; } nsresult NrIceCtx::SetResolver(nr_resolver *resolver) { int r = nr_ice_ctx_set_resolver(ctx_, resolver); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't set resolver for '" << name_ << "'"); return NS_ERROR_FAILURE; } return NS_OK; } nsresult NrIceCtx::SetProxyServer(const NrIceProxyServer& proxy_server) { int r,_status; nr_proxy_tunnel_config *config = nullptr; nr_socket_wrapper_factory *wrapper = nullptr; if ((r = nr_proxy_tunnel_config_create(&config))) { ABORT(r); } if ((r = nr_proxy_tunnel_config_set_proxy(config, proxy_server.host().c_str(), proxy_server.port()))) { ABORT(r); } if ((r = nr_proxy_tunnel_config_set_resolver(config, ctx_->resolver))) { ABORT(r); } if ((r = nr_socket_wrapper_factory_proxy_tunnel_create(config, &wrapper))) { MOZ_MTLOG(LogLevel::Error, "Couldn't create proxy tunnel wrapper."); ABORT(r); } // nr_ice_ctx will own the wrapper after this call if ((r = nr_ice_ctx_set_turn_tcp_socket_wrapper(ctx_, wrapper))) { MOZ_MTLOG(ML_ERROR, "Couldn't set proxy for '" << name_ << "': " << r); ABORT(r); } _status = 0; abort: nr_proxy_tunnel_config_destroy(&config); if (_status) { nr_socket_wrapper_factory_destroy(&wrapper); return NS_ERROR_FAILURE; } return NS_OK; } nsresult NrIceCtx::StartGathering() { ASSERT_ON_THREAD(sts_target_); if (policy_ == ICE_POLICY_NONE) { return NS_OK; } SetGatheringState(ICE_CTX_GATHER_STARTED); // This might start gathering for the first time, or again after // renegotiation, or might do nothing at all if gathering has already // finished. int r = nr_ice_gather(ctx_, &NrIceCtx::gather_cb, this); if (!r) { SetGatheringState(ICE_CTX_GATHER_COMPLETE); } else if (r != R_WOULDBLOCK) { MOZ_MTLOG(ML_ERROR, "Couldn't gather ICE candidates for '" << name_ << "', error=" << r); SetConnectionState(ICE_CTX_FAILED); return NS_ERROR_FAILURE; } return NS_OK; } RefPtr NrIceCtx::FindStream( nr_ice_media_stream *stream) { for (size_t i=0; istream() == stream)) { return streams_[i]; } } return nullptr; } std::vector NrIceCtx::GetGlobalAttributes() { char **attrs = 0; int attrct; int r; std::vector ret; r = nr_ice_get_global_attributes(ctx_, &attrs, &attrct); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't get ufrag and password for '" << name_ << "'"); return ret; } for (int i=0; i attrs) { std::vector attrs_in; for (size_t i=0; i(attrs[i].c_str())); } int r = nr_ice_peer_ctx_parse_global_attributes(peer_, attrs_in.size() ? &attrs_in[0] : nullptr, attrs_in.size()); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't parse global attributes for " << name_ << "'"); return NS_ERROR_FAILURE; } return NS_OK; } nsresult NrIceCtx::StartChecks() { int r; if (policy_ == ICE_POLICY_NONE) { MOZ_MTLOG(ML_ERROR, "Couldn't start peer checks because policy == none"); SetConnectionState(ICE_CTX_FAILED); return NS_ERROR_FAILURE; } r=nr_ice_peer_ctx_pair_candidates(peer_); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't pair candidates on " << name_ << "'"); SetConnectionState(ICE_CTX_FAILED); return NS_ERROR_FAILURE; } r = nr_ice_peer_ctx_start_checks2(peer_,1); if (r) { if (r == R_NOT_FOUND) { MOZ_MTLOG(ML_ERROR, "Couldn't start peer checks on " << name_ << "' assuming trickle ICE"); } else { MOZ_MTLOG(ML_ERROR, "Couldn't start peer checks on " << name_ << "'"); SetConnectionState(ICE_CTX_FAILED); return NS_ERROR_FAILURE; } } return NS_OK; } void NrIceCtx::gather_cb(NR_SOCKET s, int h, void *arg) { NrIceCtx *ctx = static_cast(arg); ctx->SetGatheringState(ICE_CTX_GATHER_COMPLETE); } nsresult NrIceCtx::Finalize() { int r = nr_ice_ctx_finalize(ctx_, peer_); if (r) { MOZ_MTLOG(ML_ERROR, "Couldn't finalize " << name_ << "'"); return NS_ERROR_FAILURE; } return NS_OK; } void NrIceCtx::SetConnectionState(ConnectionState state) { if (state == connection_state_) return; MOZ_MTLOG(ML_INFO, "NrIceCtx(" << name_ << "): state " << connection_state_ << "->" << state); connection_state_ = state; if (connection_state_ == ICE_CTX_FAILED) { MOZ_MTLOG(ML_INFO, "NrIceCtx(" << name_ << "): dumping r_log ringbuffer... "); std::deque logs; RLogRingBuffer::GetInstance()->GetAny(0, &logs); for (auto l = logs.begin(); l != logs.end(); ++l) { MOZ_MTLOG(ML_INFO, *l); } } SignalConnectionStateChange(this, state); } void NrIceCtx::SetGatheringState(GatheringState state) { if (state == gathering_state_) return; MOZ_MTLOG(ML_DEBUG, "NrIceCtx(" << name_ << "): gathering state " << gathering_state_ << "->" << state); gathering_state_ = state; SignalGatheringStateChange(this, state); } } // close namespace // Reimplement nr_ice_compute_codeword to avoid copyright issues void nr_ice_compute_codeword(char *buf, int len,char *codeword) { UINT4 c; r_crc32(buf,len,&c); PL_Base64Encode(reinterpret_cast(&c), 3, codeword); codeword[4] = 0; return; }