The Tor Browser / file comparison
comparison: media/mtransport/nriceresolver.cpp
media/mtransport/nriceresolver.cpp
- branch
- TOR_BUG_9701
- changeset 8
- 97036ab72558
equal
deleted
inserted
replaced
| -1:000000000000 | 0:80f76488ab54 |
|---|---|
| 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 | |
| 8 // Original authors: jib@mozilla.com, ekr@rtfm.com | |
| 9 | |
| 10 // Some of this code is cut-and-pasted from nICEr. Copyright is: | |
| 11 | |
| 12 /* | |
| 13 Copyright (c) 2007, Adobe Systems, Incorporated | |
| 14 All rights reserved. | |
| 15 | |
| 16 Redistribution and use in source and binary forms, with or without | |
| 17 modification, are permitted provided that the following conditions are | |
| 18 met: | |
| 19 | |
| 20 * Redistributions of source code must retain the above copyright | |
| 21 notice, this list of conditions and the following disclaimer. | |
| 22 | |
| 23 * Redistributions in binary form must reproduce the above copyright | |
| 24 notice, this list of conditions and the following disclaimer in the | |
| 25 documentation and/or other materials provided with the distribution. | |
| 26 | |
| 27 * Neither the name of Adobe Systems, Network Resonance nor the names of its | |
| 28 contributors may be used to endorse or promote products derived from | |
| 29 this software without specific prior written permission. | |
| 30 | |
| 31 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 32 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 33 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 34 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 35 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 36 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 37 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 38 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 39 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 40 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 41 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 42 */ | |
| 43 | |
| 44 #include "logging.h" | |
| 45 #include "nspr.h" | |
| 46 #include "prnetdb.h" | |
| 47 | |
| 48 #include "mozilla/Assertions.h" | |
| 49 | |
| 50 extern "C" { | |
| 51 #include "nr_api.h" | |
| 52 #include "async_timer.h" | |
| 53 #include "nr_resolver.h" | |
| 54 #include "transport_addr.h" | |
| 55 } | |
| 56 | |
| 57 #include "mozilla/net/DNS.h" // TODO(jib@mozilla.com) down here because bug 848578 | |
| 58 #include "nsThreadUtils.h" | |
| 59 #include "nsServiceManagerUtils.h" | |
| 60 #include "nsIDNSService.h" | |
| 61 #include "nsIDNSListener.h" | |
| 62 #include "nsIDNSRecord.h" | |
| 63 #include "nsNetCID.h" | |
| 64 #include "nsCOMPtr.h" | |
| 65 #include "nriceresolver.h" | |
| 66 #include "nr_socket_prsock.h" | |
| 67 #include "mtransport/runnable_utils.h" | |
| 68 | |
| 69 namespace mozilla { | |
| 70 | |
| 71 MOZ_MTLOG_MODULE("mtransport") | |
| 72 | |
| 73 NrIceResolver::NrIceResolver() : | |
| 74 vtbl_(new nr_resolver_vtbl()) | |
| 75 #ifdef DEBUG | |
| 76 , allocated_resolvers_(0) | |
| 77 #endif | |
| 78 { | |
| 79 vtbl_->destroy = &NrIceResolver::destroy; | |
| 80 vtbl_->resolve = &NrIceResolver::resolve; | |
| 81 vtbl_->cancel = &NrIceResolver::cancel; | |
| 82 } | |
| 83 | |
| 84 NrIceResolver::~NrIceResolver() { | |
| 85 MOZ_ASSERT(!allocated_resolvers_); | |
| 86 delete vtbl_; | |
| 87 } | |
| 88 | |
| 89 nsresult NrIceResolver::Init() { | |
| 90 nsresult rv; | |
| 91 | |
| 92 sts_thread_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); | |
| 93 MOZ_ASSERT(NS_SUCCEEDED(rv)); | |
| 94 dns_ = do_GetService(NS_DNSSERVICE_CONTRACTID, &rv); | |
| 95 if (NS_FAILED(rv)) { | |
| 96 MOZ_MTLOG(ML_ERROR, "Could not acquire DNS service"); | |
| 97 } | |
| 98 return rv; | |
| 99 } | |
| 100 | |
| 101 nr_resolver *NrIceResolver::AllocateResolver() { | |
| 102 nr_resolver *resolver; | |
| 103 | |
| 104 int r = nr_resolver_create_int((void *)this, vtbl_, &resolver); | |
| 105 MOZ_ASSERT(!r); | |
| 106 if(r) { | |
| 107 MOZ_MTLOG(ML_ERROR, "nr_resolver_create_int failed"); | |
| 108 return nullptr; | |
| 109 } | |
| 110 // We must be available to allocators until they all call DestroyResolver, | |
| 111 // because allocators may (and do) outlive the originator of NrIceResolver. | |
| 112 AddRef(); | |
| 113 #ifdef DEBUG | |
| 114 ++allocated_resolvers_; | |
| 115 #endif | |
| 116 return resolver; | |
| 117 } | |
| 118 | |
| 119 void NrIceResolver::DestroyResolver() { | |
| 120 #ifdef DEBUG | |
| 121 --allocated_resolvers_; | |
| 122 #endif | |
| 123 // Undoes Addref in AllocateResolver so the NrIceResolver can be freed. | |
| 124 Release(); | |
| 125 } | |
| 126 | |
| 127 int NrIceResolver::destroy(void **objp) { | |
| 128 if (!objp || !*objp) | |
| 129 return 0; | |
| 130 NrIceResolver *resolver = static_cast<NrIceResolver *>(*objp); | |
| 131 *objp = 0; | |
| 132 resolver->DestroyResolver(); | |
| 133 return 0; | |
| 134 } | |
| 135 | |
| 136 int NrIceResolver::resolve(void *obj, | |
| 137 nr_resolver_resource *resource, | |
| 138 int (*cb)(void *cb_arg, nr_transport_addr *addr), | |
| 139 void *cb_arg, | |
| 140 void **handle) { | |
| 141 MOZ_ASSERT(obj); | |
| 142 return static_cast<NrIceResolver *>(obj)->resolve(resource, cb, cb_arg, handle); | |
| 143 } | |
| 144 | |
| 145 int NrIceResolver::resolve(nr_resolver_resource *resource, | |
| 146 int (*cb)(void *cb_arg, nr_transport_addr *addr), | |
| 147 void *cb_arg, | |
| 148 void **handle) { | |
| 149 int _status; | |
| 150 MOZ_ASSERT(allocated_resolvers_ > 0); | |
| 151 ASSERT_ON_THREAD(sts_thread_); | |
| 152 nsRefPtr<PendingResolution> pr; | |
| 153 | |
| 154 if (resource->transport_protocol != IPPROTO_UDP && | |
| 155 resource->transport_protocol != IPPROTO_TCP) { | |
| 156 MOZ_MTLOG(ML_ERROR, "Only UDP and TCP are is supported."); | |
| 157 ABORT(R_NOT_FOUND); | |
| 158 } | |
| 159 pr = new PendingResolution(sts_thread_, | |
| 160 resource->port? resource->port : 3478, | |
| 161 resource->transport_protocol ? | |
| 162 resource->transport_protocol : | |
| 163 IPPROTO_UDP, | |
| 164 cb, cb_arg); | |
| 165 if (NS_FAILED(dns_->AsyncResolve(nsAutoCString(resource->domain_name), | |
| 166 nsIDNSService::RESOLVE_DISABLE_IPV6, pr, | |
| 167 sts_thread_, getter_AddRefs(pr->request_)))) { | |
| 168 MOZ_MTLOG(ML_ERROR, "AsyncResolve failed."); | |
| 169 ABORT(R_NOT_FOUND); | |
| 170 } | |
| 171 // Because the C API offers no "finished" method to release the handle we | |
| 172 // return, we cannot return the request we got from AsyncResolve directly. | |
| 173 // | |
| 174 // Instead, we return an addref'ed reference to PendingResolution itself, | |
| 175 // which in turn holds the request and coordinates between cancel and | |
| 176 // OnLookupComplete to release it only once. | |
| 177 pr.forget(handle); | |
| 178 | |
| 179 _status=0; | |
| 180 abort: | |
| 181 return _status; | |
| 182 } | |
| 183 | |
| 184 nsresult NrIceResolver::PendingResolution::OnLookupComplete( | |
| 185 nsICancelable *request, nsIDNSRecord *record, nsresult status) { | |
| 186 ASSERT_ON_THREAD(thread_); | |
| 187 // First check if we've been canceled. This is single-threaded on the STS | |
| 188 // thread, but cancel() cannot guarantee this event isn't on the queue. | |
| 189 if (!canceled_) { | |
| 190 nr_transport_addr *cb_addr = nullptr; | |
| 191 nr_transport_addr ta; | |
| 192 // TODO(jib@mozilla.com): Revisit when we do TURN. | |
| 193 if (NS_SUCCEEDED(status)) { | |
| 194 net::NetAddr na; | |
| 195 if (NS_SUCCEEDED(record->GetNextAddr(port_, &na))) { | |
| 196 MOZ_ALWAYS_TRUE (nr_netaddr_to_transport_addr(&na, &ta, | |
| 197 transport_) == 0); | |
| 198 cb_addr = &ta; | |
| 199 } | |
| 200 } | |
| 201 cb_(cb_arg_, cb_addr); | |
| 202 Release(); | |
| 203 } | |
| 204 return NS_OK; | |
| 205 } | |
| 206 | |
| 207 int NrIceResolver::cancel(void *obj, void *handle) { | |
| 208 MOZ_ALWAYS_TRUE(obj); | |
| 209 MOZ_ASSERT(handle); | |
| 210 ASSERT_ON_THREAD(static_cast<NrIceResolver *>(obj)->sts_thread_); | |
| 211 return static_cast<PendingResolution *>(handle)->cancel(); | |
| 212 } | |
| 213 | |
| 214 int NrIceResolver::PendingResolution::cancel() { | |
| 215 request_->Cancel (NS_ERROR_ABORT); | |
| 216 canceled_ = true; // in case OnLookupComplete is already on event queue. | |
| 217 Release(); | |
| 218 return 0; | |
| 219 } | |
| 220 | |
| 221 NS_IMPL_ISUPPORTS(NrIceResolver::PendingResolution, nsIDNSListener); | |
| 222 } // End of namespace mozilla |
