ipc/unixsocket/SocketBase.cpp

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  */
   8
   9 #include "SocketBase.h"
  10 #include <errno.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13
  14 namespace mozilla {
  15 namespace ipc {
  16
  17 //
  18 // UnixSocketIOBuffer
  19 //
  20
  21 UnixSocketIOBuffer::UnixSocketIOBuffer(const void* aData, size_t aSize)
  22 : mSize(aSize)
  23 , mOffset(0)
  24 , mAvailableSpace(aSize)
  25 {
  26   MOZ_ASSERT(aData || !mSize);
  27
  28   mData = new uint8_t[mAvailableSpace];
  29   memcpy(mData, aData, mSize);
  30 }
  31
  32 UnixSocketIOBuffer::UnixSocketIOBuffer(size_t aAvailableSpace)
  33 : mSize(0)
  34 , mOffset(0)
  35 , mAvailableSpace(aAvailableSpace)
  36 {
  37   mData = new uint8_t[mAvailableSpace];
  38 }
  39
  40 UnixSocketIOBuffer::~UnixSocketIOBuffer()
  41 { }
  42
  43 const uint8_t*
  44 UnixSocketIOBuffer::Consume(size_t aLen)
  45 {
  46   if (NS_WARN_IF(GetSize() < aLen)) {
  47     return nullptr;
  48   }
  49   uint8_t* data = mData + mOffset;
  50   mOffset += aLen;
  51   return data;
  52 }
  53
  54 nsresult
  55 UnixSocketIOBuffer::Read(void* aValue, size_t aLen)
  56 {
  57   const uint8_t* data = Consume(aLen);
  58   if (!data) {
  59     return NS_ERROR_OUT_OF_MEMORY;
  60   }
  61   memcpy(aValue, data, aLen);
  62   return NS_OK;
  63 }
  64
  65 uint8_t*
  66 UnixSocketIOBuffer::Append(size_t aLen)
  67 {
  68   if (((mAvailableSpace - mSize) < aLen)) {
  69     size_t availableSpace = mAvailableSpace + std::max(mAvailableSpace, aLen);
  70     uint8_t* data = new uint8_t[availableSpace];
  71     memcpy(data, mData, mSize);
  72     mData = data;
  73     mAvailableSpace = availableSpace;
  74   }
  75   uint8_t* data = mData + mSize;
  76   mSize += aLen;
  77   return data;
  78 }
  79
  80 nsresult
  81 UnixSocketIOBuffer::Write(const void* aValue, size_t aLen)
  82 {
  83   uint8_t* data = Append(aLen);
  84   if (!data) {
  85     return NS_ERROR_OUT_OF_MEMORY;
  86   }
  87   memcpy(data, aValue, aLen);
  88   return NS_OK;
  89 }
  90
  91 void
  92 UnixSocketIOBuffer::CleanupLeadingSpace()
  93 {
  94   if (GetLeadingSpace()) {
  95     if (GetSize() <= GetLeadingSpace()) {
  96       memcpy(mData, GetData(), GetSize());
  97     } else {
  98       memmove(mData, GetData(), GetSize());
  99     }
 100     mOffset = 0;
 101   }
 102 }
 103
 104 //
 105 // UnixSocketRawData
 106 //
 107
 108 UnixSocketRawData::UnixSocketRawData(const void* aData, size_t aSize)
 109 : UnixSocketIOBuffer(aData, aSize)
 110 { }
 111
 112 UnixSocketRawData::UnixSocketRawData(size_t aSize)
 113 : UnixSocketIOBuffer(aSize)
 114 { }
 115
 116 ssize_t
 117 UnixSocketRawData::Receive(int aFd)
 118 {
 119   if (!GetTrailingSpace()) {
 120     if (!GetLeadingSpace()) {
 121       return -1; /* buffer is full */
 122     }
 123     /* free up space at the end of data buffer */
 124     CleanupLeadingSpace();
 125   }
 126
 127   ssize_t res =
 128     TEMP_FAILURE_RETRY(read(aFd, GetTrailingBytes(), GetTrailingSpace()));
 129
 130   if (res < 0) {
 131     /* I/O error */
 132     return -1;
 133   } else if (!res) {
 134     /* EOF or peer shutdown sending */
 135     return 0;
 136   }
 137
 138   Append(res); /* mark read data as 'valid' */
 139
 140   return res;
 141 }
 142
 143 ssize_t
 144 UnixSocketRawData::Send(int aFd)
 145 {
 146   if (!GetSize()) {
 147     return 0;
 148   }
 149
 150   ssize_t res = TEMP_FAILURE_RETRY(write(aFd, GetData(), GetSize()));
 151
 152   if (res < 0) {
 153     if (errno == EAGAIN || errno == EWOULDBLOCK) {
 154       return 0; /* socket is blocked; try again later */
 155     }
 156     return -1;
 157   } else if (!res) {
 158     /* nothing written */
 159     return 0;
 160   }
 161
 162   Consume(res);
 163
 164   return res;
 165 }
 166
 167 //
 168 // SocketBase
 169 //
 170
 171 SocketBase::~SocketBase()
 172 {
 173   MOZ_ASSERT(mConnectionStatus == SOCKET_DISCONNECTED);
 174 }
 175
 176 SocketConnectionStatus
 177 SocketBase::GetConnectionStatus() const
 178 {
 179   MOZ_ASSERT(NS_IsMainThread());
 180
 181   return mConnectionStatus;
 182 }
 183
 184 int
 185 SocketBase::GetSuggestedConnectDelayMs() const
 186 {
 187   MOZ_ASSERT(NS_IsMainThread());
 188
 189   return mConnectDelayMs;
 190 }
 191
 192 void
 193 SocketBase::NotifySuccess()
 194 {
 195   MOZ_ASSERT(NS_IsMainThread());
 196
 197   mConnectionStatus = SOCKET_CONNECTED;
 198   mConnectTimestamp = PR_IntervalNow();
 199   OnConnectSuccess();
 200 }
 201
 202 void
 203 SocketBase::NotifyError()
 204 {
 205   MOZ_ASSERT(NS_IsMainThread());
 206
 207   mConnectionStatus = SOCKET_DISCONNECTED;
 208   mConnectDelayMs = CalculateConnectDelayMs();
 209   mConnectTimestamp = 0;
 210   OnConnectError();
 211 }
 212
 213 void
 214 SocketBase::NotifyDisconnect()
 215 {
 216   MOZ_ASSERT(NS_IsMainThread());
 217
 218   mConnectionStatus = SOCKET_DISCONNECTED;
 219   mConnectDelayMs = CalculateConnectDelayMs();
 220   mConnectTimestamp = 0;
 221   OnDisconnect();
 222 }
 223
 224 uint32_t
 225 SocketBase::CalculateConnectDelayMs() const
 226 {
 227   MOZ_ASSERT(NS_IsMainThread());
 228
 229   uint32_t connectDelayMs = mConnectDelayMs;
 230
 231   if (mConnectTimestamp && (PR_IntervalNow()-mConnectTimestamp) > connectDelayMs) {
 232     // reset delay if connection has been opened for a while, or...
 233     connectDelayMs = 0;
 234   } else if (!connectDelayMs) {
 235     // ...start with a delay of ~1 sec, or...
 236     connectDelayMs = 1<<10;
 237   } else if (connectDelayMs < (1<<16)) {
 238     // ...otherwise increase delay by a factor of 2
 239     connectDelayMs <<= 1;
 240   }
 241   return connectDelayMs;
 242 }
 243
 244 SocketBase::SocketBase()
 245 : mConnectionStatus(SOCKET_DISCONNECTED)
 246 , mConnectTimestamp(0)
 247 , mConnectDelayMs(0)
 248 { }
 249
 250 void
 251 SocketBase::SetConnectionStatus(SocketConnectionStatus aConnectionStatus)
 252 {
 253   mConnectionStatus = aConnectionStatus;
 254 }
 255
 256 //
 257 // SocketConsumerBase
 258 //
 259
 260 SocketConsumerBase::~SocketConsumerBase()
 261 { }
 262
 263 //
 264 // SocketIOBase
 265 //
 266
 267 SocketIOBase::~SocketIOBase()
 268 { }
 269
 270 void
 271 SocketIOBase::EnqueueData(UnixSocketRawData* aData)
 272 {
 273   if (!aData->GetSize()) {
 274     delete aData; // delete empty data immediately
 275     return;
 276   }
 277   mOutgoingQ.AppendElement(aData);
 278 }
 279
 280 bool
 281 SocketIOBase::HasPendingData() const
 282 {
 283   return !mOutgoingQ.IsEmpty();
 284 }
 285
 286 SocketIOBase::SocketIOBase(size_t aMaxReadSize)
 287   : mMaxReadSize(aMaxReadSize)
 288 {
 289   MOZ_ASSERT(mMaxReadSize);
 290 }
 291
 292 }
 293 }