The Tor Browser: dom/network/src/UDPSocketParent.cpp@b8a032363ba2 (annotated)

dom/network/src/UDPSocketParent.cpp@b8a032363ba2 (annotated)

dom/network/src/UDPSocketParent.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=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/. */
 #include "nsIServiceManager.h"
 #include "UDPSocketParent.h"
 #include "nsComponentManagerUtils.h"
 #include "nsIUDPSocket.h"
 #include "nsINetAddr.h"
 #include "mozilla/unused.h"
 #include "mozilla/net/DNS.h"
 namespace mozilla {
 namespace dom {
 static void
 FireInternalError(mozilla::net::PUDPSocketParent *aActor, uint32_t aLineNo)
 {
   mozilla::unused <<
       aActor->SendCallback(NS_LITERAL_CSTRING("onerror"),
                           UDPError(NS_LITERAL_CSTRING("Internal error"),
                                    NS_LITERAL_CSTRING(__FILE__), aLineNo, 0),
                           NS_LITERAL_CSTRING("connecting"));
 }
 static nsresult
 ConvertNetAddrToString(mozilla::net::NetAddr &netAddr, nsACString *address, uint16_t *port)
 {
   NS_ENSURE_ARG_POINTER(address);
   NS_ENSURE_ARG_POINTER(port);
   *port = 0;
   uint32_t bufSize = 0;
   switch(netAddr.raw.family) {
   case AF_INET:
     *port = PR_ntohs(netAddr.inet.port);
     bufSize = mozilla::net::kIPv4CStrBufSize;
     break;
   case AF_INET6:
     *port = PR_ntohs(netAddr.inet6.port);
     bufSize = mozilla::net::kIPv6CStrBufSize;
     break;
   default:
     //impossible
     MOZ_ASSERT(false, "Unexpected address family");
     return NS_ERROR_INVALID_ARG;
   }
   address->SetCapacity(bufSize);
   NetAddrToString(&netAddr, address->BeginWriting(), bufSize);
   address->SetLength(strlen(address->BeginReading()));
   return NS_OK;
 }
 NS_IMPL_ISUPPORTS(UDPSocketParent, nsIUDPSocketListener)
 UDPSocketParent::~UDPSocketParent()
 {
 }
 // PUDPSocketParent methods
 bool
 UDPSocketParent::Init(const nsCString &aHost, const uint16_t aPort)
 {
   nsresult rv;
   NS_ASSERTION(mFilter, "No packet filter");
   nsCOMPtr<nsIUDPSocket> sock =
       do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
   if (NS_FAILED(rv)) {
     FireInternalError(this, __LINE__);
     return true;
   }
   if (aHost.IsEmpty()) {
     rv = sock->Init(aPort, false);
   } else {
     PRNetAddr prAddr;
     PR_InitializeNetAddr(PR_IpAddrAny, aPort, &prAddr);
     PRStatus status = PR_StringToNetAddr(aHost.BeginReading(), &prAddr);
     if (status != PR_SUCCESS) {
       FireInternalError(this, __LINE__);
       return true;
     }
     mozilla::net::NetAddr addr;
     PRNetAddrToNetAddr(&prAddr, &addr);
     rv = sock->InitWithAddress(&addr);
   }
   if (NS_FAILED(rv)) {
     FireInternalError(this, __LINE__);
     return true;
   }
   mSocket = sock;
   net::NetAddr localAddr;
   mSocket->GetAddress(&localAddr);
   uint16_t port;
   nsCString addr;
   rv = ConvertNetAddrToString(localAddr, &addr, &port);
   if (NS_FAILED(rv)) {
     FireInternalError(this, __LINE__);
     return true;
   }
   // register listener
   mSocket->AsyncListen(this);
   mozilla::unused <<
       PUDPSocketParent::SendCallback(NS_LITERAL_CSTRING("onopen"),
                                      UDPAddressInfo(addr, port),
                                      NS_LITERAL_CSTRING("connected"));
   return true;
 }
 bool
 UDPSocketParent::RecvData(const InfallibleTArray<uint8_t> &aData,
                           const nsCString& aRemoteAddress,
                           const uint16_t& aPort)
 {
   NS_ENSURE_TRUE(mSocket, true);
   NS_ASSERTION(mFilter, "No packet filter");
   // TODO, Bug 933102, filter packets that are sent with hostname.
   // Until then we simply throw away packets that are sent to a hostname.
   return true;
 #if 0
   // Enable this once we have filtering working with hostname delivery.
   uint32_t count;
   nsresult rv = mSocket->Send(aRemoteAddress,
                               aPort, aData.Elements(),
                               aData.Length(), &count);
   mozilla::unused <<
       PUDPSocketParent::SendCallback(NS_LITERAL_CSTRING("onsent"),
                                      UDPSendResult(rv),
                                      NS_LITERAL_CSTRING("connected"));
   NS_ENSURE_SUCCESS(rv, true);
   NS_ENSURE_TRUE(count > 0, true);
   return true;
 #endif
 }
 bool
 UDPSocketParent::RecvDataWithAddress(const InfallibleTArray<uint8_t>& aData,
                                      const mozilla::net::NetAddr& aAddr)
 {
   NS_ENSURE_TRUE(mSocket, true);
   NS_ASSERTION(mFilter, "No packet filter");
   uint32_t count;
   nsresult rv;
   bool allowed;
   rv = mFilter->FilterPacket(&aAddr, aData.Elements(),
                              aData.Length(), nsIUDPSocketFilter::SF_OUTGOING,
                              &allowed);
   // Sending unallowed data, kill content.
   NS_ENSURE_SUCCESS(rv, false);
   NS_ENSURE_TRUE(allowed, false);
   rv = mSocket->SendWithAddress(&aAddr, aData.Elements(),
                                 aData.Length(), &count);
   mozilla::unused <<
       PUDPSocketParent::SendCallback(NS_LITERAL_CSTRING("onsent"),
                                      UDPSendResult(rv),
                                      NS_LITERAL_CSTRING("connected"));
   NS_ENSURE_SUCCESS(rv, true);
   NS_ENSURE_TRUE(count > 0, true);
   return true;
 }
 bool
 UDPSocketParent::RecvClose()
 {
   NS_ENSURE_TRUE(mSocket, true);
   nsresult rv = mSocket->Close();
   mSocket = nullptr;
   NS_ENSURE_SUCCESS(rv, true);
   return true;
 }
 bool
 UDPSocketParent::RecvRequestDelete()
 {
   mozilla::unused << Send__delete__(this);
   return true;
 }
 void
 UDPSocketParent::ActorDestroy(ActorDestroyReason why)
 {
   MOZ_ASSERT(mIPCOpen);
   mIPCOpen = false;
   if (mSocket) {
     mSocket->Close();
   }
   mSocket = nullptr;
 }
 // nsIUDPSocketListener
 NS_IMETHODIMP
 UDPSocketParent::OnPacketReceived(nsIUDPSocket* aSocket, nsIUDPMessage* aMessage)
 {
   // receiving packet from remote host, forward the message content to child process
   if (!mIPCOpen) {
     return NS_OK;
   }
   NS_ASSERTION(mFilter, "No packet filter");
   uint16_t port;
   nsCString ip;
   nsCOMPtr<nsINetAddr> fromAddr;
   aMessage->GetFromAddr(getter_AddRefs(fromAddr));
   fromAddr->GetPort(&port);
   fromAddr->GetAddress(ip);
   nsCString data;
   aMessage->GetData(data);
   const char* buffer = data.get();
   uint32_t len = data.Length();
   bool allowed;
   mozilla::net::NetAddr addr;
   fromAddr->GetNetAddr(&addr);
   nsresult rv = mFilter->FilterPacket(&addr,
                                       (const uint8_t*)buffer, len,
                                       nsIUDPSocketFilter::SF_INCOMING,
                                       &allowed);
   // Receiving unallowed data, drop.
   NS_ENSURE_SUCCESS(rv, NS_OK);
   NS_ENSURE_TRUE(allowed, NS_OK);
   FallibleTArray<uint8_t> fallibleArray;
   if (!fallibleArray.InsertElementsAt(0, buffer, len)) {
     FireInternalError(this, __LINE__);
     return NS_ERROR_OUT_OF_MEMORY;
   }
   InfallibleTArray<uint8_t> infallibleArray;
   infallibleArray.SwapElements(fallibleArray);
   // compose callback
   mozilla::unused <<
       PUDPSocketParent::SendCallback(NS_LITERAL_CSTRING("ondata"),
                                      UDPMessage(ip, port, infallibleArray),
                                      NS_LITERAL_CSTRING("connected"));
   return NS_OK;
 }
 NS_IMETHODIMP
 UDPSocketParent::OnStopListening(nsIUDPSocket* aSocket, nsresult aStatus)
 {
   // underlying socket is dead, send state update to child process
   if (mIPCOpen) {
     mozilla::unused <<
         PUDPSocketParent::SendCallback(NS_LITERAL_CSTRING("onclose"),
                                        mozilla::void_t(),
                                        NS_LITERAL_CSTRING("closed"));
   }
   return NS_OK;
 }
 } // namespace dom
 } // namespace mozilla

The Tor Browser / annotate

dom/network/src/UDPSocketParent.cpp@b8a032363ba2 (annotated)

dom/network/src/UDPSocketParent.cpp