dom/network/UDPSocketChild.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "UDPSocketChild.h"
   6 #include "mozilla/unused.h"
   7 #include "mozilla/ipc/InputStreamUtils.h"
   8 #include "mozilla/net/NeckoChild.h"
   9
  10 using mozilla::net::gNeckoChild;
  11
  12 namespace mozilla {
  13 namespace dom {
  14
  15 NS_IMPL_ISUPPORTS(UDPSocketChildBase, nsIUDPSocketChild)
  16
  17 UDPSocketChildBase::UDPSocketChildBase()
  18 : mIPCOpen(false)
  19 {
  20 }
  21
  22 UDPSocketChildBase::~UDPSocketChildBase()
  23 {
  24 }
  25
  26 void
  27 UDPSocketChildBase::ReleaseIPDLReference()
  28 {
  29   MOZ_ASSERT(mIPCOpen);
  30   mIPCOpen = false;
  31   mSocket = nullptr;
  32   this->Release();
  33 }
  34
  35 void
  36 UDPSocketChildBase::AddIPDLReference()
  37 {
  38   MOZ_ASSERT(!mIPCOpen);
  39   mIPCOpen = true;
  40   this->AddRef();
  41 }
  42
  43 NS_IMETHODIMP_(MozExternalRefCountType) UDPSocketChild::Release(void)
  44 {
  45   nsrefcnt refcnt = UDPSocketChildBase::Release();
  46   if (refcnt == 1 && mIPCOpen) {
  47     PUDPSocketChild::SendRequestDelete();
  48     return 1;
  49   }
  50   return refcnt;
  51 }
  52
  53 UDPSocketChild::UDPSocketChild()
  54 :mLocalPort(0)
  55 {
  56 }
  57
  58 UDPSocketChild::~UDPSocketChild()
  59 {
  60 }
  61
  62 // nsIUDPSocketChild Methods
  63
  64 NS_IMETHODIMP
  65 UDPSocketChild::Bind(nsIUDPSocketInternal* aSocket,
  66                      const nsACString& aHost,
  67                      uint16_t aPort,
  68                      bool aAddressReuse,
  69                      bool aLoopback)
  70 {
  71   NS_ENSURE_ARG(aSocket);
  72
  73   mSocket = aSocket;
  74   AddIPDLReference();
  75
  76   gNeckoChild->SendPUDPSocketConstructor(this, mFilterName);
  77
  78   SendBind(UDPAddressInfo(nsCString(aHost), aPort), aAddressReuse, aLoopback);
  79   return NS_OK;
  80 }
  81
  82 NS_IMETHODIMP
  83 UDPSocketChild::Close()
  84 {
  85   SendClose();
  86   return NS_OK;
  87 }
  88
  89 NS_IMETHODIMP
  90 UDPSocketChild::Send(const nsACString& aHost,
  91                      uint16_t aPort,
  92                      const uint8_t* aData,
  93                      uint32_t aByteLength)
  94 {
  95   NS_ENSURE_ARG(aData);
  96
  97   return SendDataInternal(UDPSocketAddr(UDPAddressInfo(nsCString(aHost), aPort)),
  98                           aData, aByteLength);
  99 }
 100
 101 NS_IMETHODIMP
 102 UDPSocketChild::SendWithAddr(nsINetAddr* aAddr,
 103                              const uint8_t* aData,
 104                              uint32_t aByteLength)
 105 {
 106   NS_ENSURE_ARG(aAddr);
 107   NS_ENSURE_ARG(aData);
 108
 109   NetAddr addr;
 110   aAddr->GetNetAddr(&addr);
 111
 112   return SendDataInternal(UDPSocketAddr(addr), aData, aByteLength);
 113 }
 114
 115 NS_IMETHODIMP
 116 UDPSocketChild::SendWithAddress(const NetAddr* aAddr,
 117                                 const uint8_t* aData,
 118                                 uint32_t aByteLength)
 119 {
 120   NS_ENSURE_ARG(aAddr);
 121   NS_ENSURE_ARG(aData);
 122
 123   return SendDataInternal(UDPSocketAddr(*aAddr), aData, aByteLength);
 124 }
 125
 126 nsresult
 127 UDPSocketChild::SendDataInternal(const UDPSocketAddr& aAddr,
 128                                  const uint8_t* aData,
 129                                  const uint32_t aByteLength)
 130 {
 131   NS_ENSURE_ARG(aData);
 132
 133   FallibleTArray<uint8_t> fallibleArray;
 134   if (!fallibleArray.InsertElementsAt(0, aData, aByteLength)) {
 135     return NS_ERROR_OUT_OF_MEMORY;
 136   }
 137
 138   InfallibleTArray<uint8_t> array;
 139   array.SwapElements(fallibleArray);
 140
 141   SendOutgoingData(array, aAddr);
 142
 143   return NS_OK;
 144 }
 145
 146 NS_IMETHODIMP
 147 UDPSocketChild::SendBinaryStream(const nsACString& aHost,
 148                                  uint16_t aPort,
 149                                  nsIInputStream* aStream)
 150 {
 151   NS_ENSURE_ARG(aStream);
 152
 153   OptionalInputStreamParams stream;
 154   nsTArray<mozilla::ipc::FileDescriptor> fds;
 155   SerializeInputStream(aStream, stream, fds);
 156
 157   MOZ_ASSERT(fds.IsEmpty());
 158
 159   SendOutgoingData(UDPData(stream), UDPSocketAddr(UDPAddressInfo(nsCString(aHost), aPort)));
 160
 161   return NS_OK;
 162 }
 163
 164 NS_IMETHODIMP
 165 UDPSocketChild::JoinMulticast(const nsACString& aMulticastAddress,
 166                               const nsACString& aInterface)
 167 {
 168   SendJoinMulticast(nsCString(aMulticastAddress), nsCString(aInterface));
 169   return NS_OK;
 170 }
 171
 172 NS_IMETHODIMP
 173 UDPSocketChild::LeaveMulticast(const nsACString& aMulticastAddress,
 174                                const nsACString& aInterface)
 175 {
 176   SendLeaveMulticast(nsCString(aMulticastAddress), nsCString(aInterface));
 177   return NS_OK;
 178 }
 179
 180 NS_IMETHODIMP
 181 UDPSocketChild::GetLocalPort(uint16_t* aLocalPort)
 182 {
 183   NS_ENSURE_ARG_POINTER(aLocalPort);
 184
 185   *aLocalPort = mLocalPort;
 186   return NS_OK;
 187 }
 188
 189 NS_IMETHODIMP
 190 UDPSocketChild::GetLocalAddress(nsACString& aLocalAddress)
 191 {
 192   aLocalAddress = mLocalAddress;
 193   return NS_OK;
 194 }
 195
 196 NS_IMETHODIMP
 197 UDPSocketChild::SetFilterName(const nsACString& aFilterName)
 198 {
 199   if (!mFilterName.IsEmpty()) {
 200     // filter name can only be set once.
 201     return NS_ERROR_FAILURE;
 202   }
 203   mFilterName = aFilterName;
 204   return NS_OK;
 205 }
 206
 207 NS_IMETHODIMP
 208 UDPSocketChild::GetFilterName(nsACString& aFilterName)
 209 {
 210   aFilterName = mFilterName;
 211   return NS_OK;
 212 }
 213
 214 // PUDPSocketChild Methods
 215 bool
 216 UDPSocketChild::RecvCallbackOpened(const UDPAddressInfo& aAddressInfo)
 217 {
 218   mLocalAddress = aAddressInfo.addr();
 219   mLocalPort = aAddressInfo.port();
 220
 221   nsresult rv = mSocket->CallListenerOpened();
 222   mozilla::unused << NS_WARN_IF(NS_FAILED(rv));
 223
 224   return true;
 225 }
 226
 227 bool
 228 UDPSocketChild::RecvCallbackClosed()
 229 {
 230   nsresult rv = mSocket->CallListenerClosed();
 231   mozilla::unused << NS_WARN_IF(NS_FAILED(rv));
 232
 233   return true;
 234 }
 235
 236 bool
 237 UDPSocketChild::RecvCallbackReceivedData(const UDPAddressInfo& aAddressInfo,
 238                                          const InfallibleTArray<uint8_t>& aData)
 239 {
 240   nsresult rv = mSocket->CallListenerReceivedData(aAddressInfo.addr(), aAddressInfo.port(),
 241                                                   aData.Elements(), aData.Length());
 242   mozilla::unused << NS_WARN_IF(NS_FAILED(rv));
 243
 244   return true;
 245 }
 246
 247 bool
 248 UDPSocketChild::RecvCallbackError(const nsCString& aMessage,
 249                                   const nsCString& aFilename,
 250                                   const uint32_t& aLineNumber)
 251 {
 252   nsresult rv = mSocket->CallListenerError(aMessage, aFilename, aLineNumber);
 253   mozilla::unused << NS_WARN_IF(NS_FAILED(rv));
 254
 255   return true;
 256 }
 257
 258 } // namespace dom
 259 } // namespace mozilla