ipc/glue/ProtocolUtils.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=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
   5  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_ipc_ProtocolUtils_h
   8 #define mozilla_ipc_ProtocolUtils_h 1
   9
  10 #include <cstddef>
  11 #include <cstdint>
  12 #include <utility>
  13 #include "IPCMessageStart.h"
  14 #include "base/basictypes.h"
  15 #include "base/process.h"
  16 #include "chrome/common/ipc_message.h"
  17 #include "mojo/core/ports/port_ref.h"
  18 #include "mozilla/AlreadyAddRefed.h"
  19 #include "mozilla/Assertions.h"
  20 #include "mozilla/Attributes.h"
  21 #include "mozilla/FunctionRef.h"
  22 #include "mozilla/Maybe.h"
  23 #include "mozilla/Mutex.h"
  24 #include "mozilla/RefPtr.h"
  25 #include "mozilla/Scoped.h"
  26 #include "mozilla/UniquePtr.h"
  27 #include "mozilla/ipc/MessageChannel.h"
  28 #include "mozilla/ipc/MessageLink.h"
  29 #include "mozilla/ipc/SharedMemory.h"
  30 #include "mozilla/ipc/Shmem.h"
  31 #include "nsTHashMap.h"
  32 #include "nsDebug.h"
  33 #include "nsISupports.h"
  34 #include "nsTArrayForwardDeclare.h"
  35 #include "nsTHashSet.h"
  36
  37 // XXX Things that could be moved to ProtocolUtils.cpp
  38 #include "base/process_util.h"  // for CloseProcessHandle
  39 #include "prenv.h"              // for PR_GetEnv
  40
  41 #if defined(ANDROID) && defined(DEBUG)
  42 #  include <android/log.h>
  43 #endif
  44
  45 template <typename T>
  46 class nsPtrHashKey;
  47
  48 // WARNING: this takes into account the private, special-message-type
  49 // enum in ipc_channel.h.  They need to be kept in sync.
  50 namespace {
  51 // XXX the max message ID is actually kuint32max now ... when this
  52 // changed, the assumptions of the special message IDs changed in that
  53 // they're not carving out messages from likely-unallocated space, but
  54 // rather carving out messages from the end of space allocated to
  55 // protocol 0.  Oops!  We can get away with this until protocol 0
  56 // starts approaching its 65,536th message.
  57 enum {
  58   // Message types used by DataPipe
  59   DATA_PIPE_CLOSED_MESSAGE_TYPE = kuint16max - 18,
  60   DATA_PIPE_BYTES_CONSUMED_MESSAGE_TYPE = kuint16max - 17,
  61
  62   // Message types used by NodeChannel
  63   ACCEPT_INVITE_MESSAGE_TYPE = kuint16max - 16,
  64   REQUEST_INTRODUCTION_MESSAGE_TYPE = kuint16max - 15,
  65   INTRODUCE_MESSAGE_TYPE = kuint16max - 14,
  66   BROADCAST_MESSAGE_TYPE = kuint16max - 13,
  67   EVENT_MESSAGE_TYPE = kuint16max - 12,
  68
  69   // Message types used by MessageChannel
  70   MANAGED_ENDPOINT_DROPPED_MESSAGE_TYPE = kuint16max - 11,
  71   MANAGED_ENDPOINT_BOUND_MESSAGE_TYPE = kuint16max - 10,
  72   IMPENDING_SHUTDOWN_MESSAGE_TYPE = kuint16max - 9,
  73   BUILD_IDS_MATCH_MESSAGE_TYPE = kuint16max - 8,
  74   BUILD_ID_MESSAGE_TYPE = kuint16max - 7,  // unused
  75   CHANNEL_OPENED_MESSAGE_TYPE = kuint16max - 6,
  76   SHMEM_DESTROYED_MESSAGE_TYPE = kuint16max - 5,
  77   SHMEM_CREATED_MESSAGE_TYPE = kuint16max - 4,
  78   GOODBYE_MESSAGE_TYPE = kuint16max - 3,
  79   CANCEL_MESSAGE_TYPE = kuint16max - 2,
  80
  81   // kuint16max - 1 is used by ipc_channel.h.
  82 };
  83
  84 }  // namespace
  85
  86 class MessageLoop;
  87 class PickleIterator;
  88 class nsISerialEventTarget;
  89
  90 namespace mozilla {
  91 class SchedulerGroup;
  92
  93 namespace dom {
  94 class ContentParent;
  95 }  // namespace dom
  96
  97 namespace net {
  98 class NeckoParent;
  99 }  // namespace net
 100
 101 namespace ipc {
 102
 103 #ifdef FUZZING
 104 class ProtocolFuzzerHelper;
 105 #endif
 106
 107 // Scoped base::ProcessHandle to ensure base::CloseProcessHandle is called.
 108 struct ScopedProcessHandleTraits {
 109   typedef base::ProcessHandle type;
 110
 111   static type empty() { return base::kInvalidProcessHandle; }
 112
 113   static void release(type aProcessHandle) {
 114     if (aProcessHandle && aProcessHandle != base::kInvalidProcessHandle) {
 115       base::CloseProcessHandle(aProcessHandle);
 116     }
 117   }
 118 };
 119 typedef mozilla::Scoped<ScopedProcessHandleTraits> ScopedProcessHandle;
 120
 121 class ProtocolFdMapping;
 122 class ProtocolCloneContext;
 123
 124 // Used to pass references to protocol actors across the wire.
 125 // Actors created on the parent-side have a positive ID, and actors
 126 // allocated on the child side have a negative ID.
 127 struct ActorHandle {
 128   int mId;
 129 };
 130
 131 // What happens if Interrupt calls race?
 132 enum RacyInterruptPolicy { RIPError, RIPChildWins, RIPParentWins };
 133
 134 enum class LinkStatus : uint8_t {
 135   // The actor has not established a link yet, or the actor is no longer in use
 136   // by IPC, and its 'Dealloc' method has been called or is being called.
 137   //
 138   // NOTE: This state is used instead of an explicit `Freed` state when IPC no
 139   // longer holds references to the current actor as we currently re-open
 140   // existing actors. Once we fix these poorly behaved actors, this loopback
 141   // state can be split to have the final state not be the same as the initial
 142   // state.
 143   Inactive,
 144
 145   // A live link is connected to the other side of this actor.
 146   Connected,
 147
 148   // The link has begun being destroyed. Messages may still be received, but
 149   // cannot be sent. (exception: sync/intr replies may be sent while Doomed).
 150   Doomed,
 151
 152   // The link has been destroyed, and messages will no longer be sent or
 153   // received.
 154   Destroyed,
 155 };
 156
 157 typedef IPCMessageStart ProtocolId;
 158
 159 // Generated by IPDL compiler
 160 const char* ProtocolIdToName(IPCMessageStart aId);
 161
 162 class IToplevelProtocol;
 163 class ActorLifecycleProxy;
 164 class WeakActorLifecycleProxy;
 165 class IPDLResolverInner;
 166 class UntypedManagedEndpoint;
 167
 168 class IProtocol : public HasResultCodes {
 169  public:
 170   enum ActorDestroyReason {
 171     FailedConstructor,
 172     Deletion,
 173     AncestorDeletion,
 174     NormalShutdown,
 175     AbnormalShutdown,
 176     ManagedEndpointDropped
 177   };
 178
 179   typedef base::ProcessId ProcessId;
 180   typedef IPC::Message Message;
 181
 182   IProtocol(ProtocolId aProtoId, Side aSide)
 183       : mId(0),
 184         mProtocolId(aProtoId),
 185         mSide(aSide),
 186         mLinkStatus(LinkStatus::Inactive),
 187         mLifecycleProxy(nullptr),
 188         mManager(nullptr),
 189         mToplevel(nullptr) {}
 190
 191   IToplevelProtocol* ToplevelProtocol() { return mToplevel; }
 192   const IToplevelProtocol* ToplevelProtocol() const { return mToplevel; }
 193
 194   // The following methods either directly forward to the toplevel protocol, or
 195   // almost directly do.
 196   int32_t Register(IProtocol* aRouted);
 197   int32_t RegisterID(IProtocol* aRouted, int32_t aId);
 198   IProtocol* Lookup(int32_t aId);
 199   void Unregister(int32_t aId);
 200
 201   Shmem::SharedMemory* CreateSharedMemory(size_t aSize,
 202                                           SharedMemory::SharedMemoryType aType,
 203                                           bool aUnsafe, int32_t* aId);
 204   Shmem::SharedMemory* LookupSharedMemory(int32_t aId);
 205   bool IsTrackingSharedMemory(Shmem::SharedMemory* aSegment);
 206   bool DestroySharedMemory(Shmem& aShmem);
 207
 208   MessageChannel* GetIPCChannel();
 209   const MessageChannel* GetIPCChannel() const;
 210
 211   // Get the nsISerialEventTarget which all messages sent to this actor will be
 212   // processed on. Unless stated otherwise, all operations on IProtocol which
 213   // don't occur on this `nsISerialEventTarget` are unsafe.
 214   nsISerialEventTarget* GetActorEventTarget();
 215
 216   // Actor lifecycle and other properties.
 217   ProtocolId GetProtocolId() const { return mProtocolId; }
 218   const char* GetProtocolName() const { return ProtocolIdToName(mProtocolId); }
 219
 220   int32_t Id() const { return mId; }
 221   IProtocol* Manager() const { return mManager; }
 222
 223   ActorLifecycleProxy* GetLifecycleProxy() { return mLifecycleProxy; }
 224   WeakActorLifecycleProxy* GetWeakLifecycleProxy();
 225
 226   Side GetSide() const { return mSide; }
 227   bool CanSend() const { return mLinkStatus == LinkStatus::Connected; }
 228   bool CanRecv() const {
 229     return mLinkStatus == LinkStatus::Connected ||
 230            mLinkStatus == LinkStatus::Doomed;
 231   }
 232
 233   // Remove or deallocate a managee given its type.
 234   virtual void RemoveManagee(int32_t, IProtocol*) = 0;
 235   virtual void DeallocManagee(int32_t, IProtocol*) = 0;
 236
 237   Maybe<IProtocol*> ReadActor(IPC::MessageReader* aReader, bool aNullable,
 238                               const char* aActorDescription,
 239                               int32_t aProtocolTypeId);
 240
 241   virtual Result OnMessageReceived(const Message& aMessage) = 0;
 242   virtual Result OnMessageReceived(const Message& aMessage,
 243                                    Message*& aReply) = 0;
 244   virtual Result OnCallReceived(const Message& aMessage, Message*& aReply) = 0;
 245   bool AllocShmem(size_t aSize, Shmem::SharedMemory::SharedMemoryType aType,
 246                   Shmem* aOutMem);
 247   bool AllocUnsafeShmem(size_t aSize,
 248                         Shmem::SharedMemory::SharedMemoryType aType,
 249                         Shmem* aOutMem);
 250   bool DeallocShmem(Shmem& aMem);
 251
 252   void FatalError(const char* const aErrorMsg) const;
 253   virtual void HandleFatalError(const char* aErrorMsg) const;
 254
 255  protected:
 256   virtual ~IProtocol();
 257
 258   friend class IToplevelProtocol;
 259   friend class ActorLifecycleProxy;
 260   friend class IPDLResolverInner;
 261   friend class UntypedManagedEndpoint;
 262
 263   void SetId(int32_t aId);
 264
 265   // We have separate functions because the accessibility code manually
 266   // calls SetManager.
 267   void SetManager(IProtocol* aManager);
 268
 269   // Sets the manager for the protocol and registers the protocol with
 270   // its manager, setting up channels for the protocol as well.  Not
 271   // for use outside of IPDL.
 272   void SetManagerAndRegister(IProtocol* aManager);
 273   void SetManagerAndRegister(IProtocol* aManager, int32_t aId);
 274
 275   // Helpers for calling `Send` on our underlying IPC channel.
 276   bool ChannelSend(IPC::Message* aMsg);
 277   bool ChannelSend(IPC::Message* aMsg, IPC::Message* aReply);
 278   template <typename Value>
 279   void ChannelSend(IPC::Message* aMsg, ResolveCallback<Value>&& aResolve,
 280                    RejectCallback&& aReject) {
 281     UniquePtr<IPC::Message> msg(aMsg);
 282     if (CanSend()) {
 283       GetIPCChannel()->Send(std::move(msg), this, std::move(aResolve),
 284                             std::move(aReject));
 285     } else {
 286       WarnMessageDiscarded(msg.get());
 287       aReject(ResponseRejectReason::SendError);
 288     }
 289   }
 290
 291   // Collect all actors managed by this object in an array. To make this safer
 292   // to iterate, `ActorLifecycleProxy` references are returned rather than raw
 293   // actor pointers.
 294   virtual void AllManagedActors(
 295       nsTArray<RefPtr<ActorLifecycleProxy>>& aActors) const = 0;
 296
 297   // Internal method called when the actor becomes connected.
 298   void ActorConnected();
 299
 300   // Called immediately before setting the actor state to doomed, and triggering
 301   // async actor destruction. Messages may be sent from this callback, but no
 302   // later.
 303   // FIXME(nika): This is currently unused!
 304   virtual void ActorDoom() {}
 305   void DoomSubtree();
 306
 307   // Called when the actor has been destroyed due to an error, a __delete__
 308   // message, or a __doom__ reply.
 309   virtual void ActorDestroy(ActorDestroyReason aWhy) {}
 310   void DestroySubtree(ActorDestroyReason aWhy);
 311
 312   // Called when IPC has acquired its first reference to the actor. This method
 313   // may take references which will later be freed by `ActorDealloc`.
 314   virtual void ActorAlloc() {}
 315
 316   // Called when IPC has released its final reference to the actor. It will call
 317   // the dealloc method, causing the actor to be actually freed.
 318   //
 319   // The actor has been freed after this method returns.
 320   virtual void ActorDealloc() {
 321     if (Manager()) {
 322       Manager()->DeallocManagee(mProtocolId, this);
 323     }
 324   }
 325
 326   static const int32_t kNullActorId = 0;
 327   static const int32_t kFreedActorId = 1;
 328
 329  private:
 330 #ifdef DEBUG
 331   void WarnMessageDiscarded(IPC::Message* aMsg);
 332 #else
 333   void WarnMessageDiscarded(IPC::Message*) {}
 334 #endif
 335
 336   int32_t mId;
 337   ProtocolId mProtocolId;
 338   Side mSide;
 339   LinkStatus mLinkStatus;
 340   ActorLifecycleProxy* mLifecycleProxy;
 341   IProtocol* mManager;
 342   IToplevelProtocol* mToplevel;
 343 };
 344
 345 #define IPC_OK() mozilla::ipc::IPCResult::Ok()
 346 #define IPC_FAIL(actor, why) \
 347   mozilla::ipc::IPCResult::Fail(WrapNotNull(actor), __func__, (why))
 348 #define IPC_FAIL_NO_REASON(actor) \
 349   mozilla::ipc::IPCResult::Fail(WrapNotNull(actor), __func__)
 350
 351 /**
 352  * All message deserializer and message handler should return this
 353  * type via above macros. We use a less generic name here to avoid
 354  * conflict with mozilla::Result because we have quite a few using
 355  * namespace mozilla::ipc; in the code base.
 356  */
 357 class IPCResult {
 358  public:
 359   static IPCResult Ok() { return IPCResult(true); }
 360   static IPCResult Fail(NotNull<IProtocol*> aActor, const char* aWhere,
 361                         const char* aWhy = "");
 362   MOZ_IMPLICIT operator bool() const { return mSuccess; }
 363
 364  private:
 365   explicit IPCResult(bool aResult) : mSuccess(aResult) {}
 366   bool mSuccess;
 367 };
 368
 369 template <class PFooSide>
 370 class Endpoint;
 371
 372 template <class PFooSide>
 373 class ManagedEndpoint;
 374
 375 /**
 376  * All top-level protocols should inherit this class.
 377  *
 378  * IToplevelProtocol tracks all top-level protocol actors created from
 379  * this protocol actor.
 380  */
 381 class IToplevelProtocol : public IProtocol {
 382 #ifdef FUZZING
 383   friend class mozilla::ipc::ProtocolFuzzerHelper;
 384 #endif
 385
 386   template <class PFooSide>
 387   friend class Endpoint;
 388
 389  protected:
 390   explicit IToplevelProtocol(const char* aName, ProtocolId aProtoId,
 391                              Side aSide);
 392   ~IToplevelProtocol() = default;
 393
 394  public:
 395   // Shadow methods on IProtocol which are implemented directly on toplevel
 396   // actors.
 397   int32_t Register(IProtocol* aRouted);
 398   int32_t RegisterID(IProtocol* aRouted, int32_t aId);
 399   IProtocol* Lookup(int32_t aId);
 400   void Unregister(int32_t aId);
 401
 402   Shmem::SharedMemory* CreateSharedMemory(size_t aSize,
 403                                           SharedMemory::SharedMemoryType aType,
 404                                           bool aUnsafe, int32_t* aId);
 405   Shmem::SharedMemory* LookupSharedMemory(int32_t aId);
 406   bool IsTrackingSharedMemory(Shmem::SharedMemory* aSegment);
 407   bool DestroySharedMemory(Shmem& aShmem);
 408
 409   MessageChannel* GetIPCChannel() { return &mChannel; }
 410   const MessageChannel* GetIPCChannel() const { return &mChannel; }
 411
 412   void SetOtherProcessId(base::ProcessId aOtherPid);
 413
 414   virtual void OnChannelClose() = 0;
 415   virtual void OnChannelError() = 0;
 416   virtual void ProcessingError(Result aError, const char* aMsgName) {}
 417
 418   bool Open(ScopedPort aPort, base::ProcessId aOtherPid);
 419
 420   bool Open(IToplevelProtocol* aTarget, nsISerialEventTarget* aEventTarget,
 421             mozilla::ipc::Side aSide = mozilla::ipc::UnknownSide);
 422
 423   // Open a toplevel actor such that both ends of the actor's channel are on
 424   // the same thread. This method should be called on the thread to perform
 425   // the link.
 426   //
 427   // WARNING: Attempting to send a sync or intr message on the same thread
 428   // will crash.
 429   bool OpenOnSameThread(IToplevelProtocol* aTarget,
 430                         mozilla::ipc::Side aSide = mozilla::ipc::UnknownSide);
 431
 432   /**
 433    * This sends a special message that is processed on the IO thread, so that
 434    * other actors can know that the process will soon shutdown.
 435    */
 436   void NotifyImpendingShutdown();
 437
 438   void Close();
 439
 440   void SetReplyTimeoutMs(int32_t aTimeoutMs);
 441
 442   void DeallocShmems();
 443   bool ShmemCreated(const Message& aMsg);
 444   bool ShmemDestroyed(const Message& aMsg);
 445
 446   virtual bool ShouldContinueFromReplyTimeout() { return false; }
 447
 448   // WARNING: This function is called with the MessageChannel monitor held.
 449   virtual void IntentionalCrash() { MOZ_CRASH("Intentional IPDL crash"); }
 450
 451   // The code here is only useful for fuzzing. It should not be used for any
 452   // other purpose.
 453 #ifdef DEBUG
 454   // Returns true if we should simulate a timeout.
 455   // WARNING: This is a testing-only function that is called with the
 456   // MessageChannel monitor held. Don't do anything fancy here or we could
 457   // deadlock.
 458   virtual bool ArtificialTimeout() { return false; }
 459
 460   // Returns true if we want to cause the worker thread to sleep with the
 461   // monitor unlocked.
 462   virtual bool NeedArtificialSleep() { return false; }
 463
 464   // This function should be implemented to sleep for some amount of time on
 465   // the worker thread. Will only be called if NeedArtificialSleep() returns
 466   // true.
 467   virtual void ArtificialSleep() {}
 468 #else
 469   bool ArtificialTimeout() { return false; }
 470   bool NeedArtificialSleep() { return false; }
 471   void ArtificialSleep() {}
 472 #endif
 473
 474   bool IsOnCxxStack() const;
 475
 476   /**
 477    * Return true if windows messages can be handled while waiting for a reply
 478    * to a sync IPDL message.
 479    */
 480   virtual bool HandleWindowsMessages(const Message& aMsg) const { return true; }
 481
 482   virtual void ProcessRemoteNativeEventsInInterruptCall() {}
 483
 484   virtual void OnChannelReceivedMessage(const Message& aMsg) {}
 485
 486   void OnIPCChannelOpened() { ActorConnected(); }
 487
 488   base::ProcessId OtherPidMaybeInvalid() const { return mOtherPid; }
 489
 490  private:
 491   int32_t NextId();
 492
 493   template <class T>
 494   using IDMap = nsTHashMap<nsUint32HashKey, T>;
 495
 496   base::ProcessId mOtherPid;
 497
 498   // NOTE NOTE NOTE
 499   // Used to be on mState
 500   int32_t mLastLocalId;
 501   IDMap<IProtocol*> mActorMap;
 502   IDMap<Shmem::SharedMemory*> mShmemMap;
 503
 504   MessageChannel mChannel;
 505 };
 506
 507 class IShmemAllocator {
 508  public:
 509   virtual bool AllocShmem(size_t aSize,
 510                           mozilla::ipc::SharedMemory::SharedMemoryType aShmType,
 511                           mozilla::ipc::Shmem* aShmem) = 0;
 512   virtual bool AllocUnsafeShmem(
 513       size_t aSize, mozilla::ipc::SharedMemory::SharedMemoryType aShmType,
 514       mozilla::ipc::Shmem* aShmem) = 0;
 515   virtual bool DeallocShmem(mozilla::ipc::Shmem& aShmem) = 0;
 516 };
 517
 518 #define FORWARD_SHMEM_ALLOCATOR_TO(aImplClass)                             \
 519   virtual bool AllocShmem(                                                 \
 520       size_t aSize, mozilla::ipc::SharedMemory::SharedMemoryType aShmType, \
 521       mozilla::ipc::Shmem* aShmem) override {                              \
 522     return aImplClass::AllocShmem(aSize, aShmType, aShmem);                \
 523   }                                                                        \
 524   virtual bool AllocUnsafeShmem(                                           \
 525       size_t aSize, mozilla::ipc::SharedMemory::SharedMemoryType aShmType, \
 526       mozilla::ipc::Shmem* aShmem) override {                              \
 527     return aImplClass::AllocUnsafeShmem(aSize, aShmType, aShmem);          \
 528   }                                                                        \
 529   virtual bool DeallocShmem(mozilla::ipc::Shmem& aShmem) override {        \
 530     return aImplClass::DeallocShmem(aShmem);                               \
 531   }
 532
 533 inline bool LoggingEnabled() {
 534 #if defined(DEBUG) || defined(FUZZING)
 535   return !!PR_GetEnv("MOZ_IPC_MESSAGE_LOG");
 536 #else
 537   return false;
 538 #endif
 539 }
 540
 541 #if defined(DEBUG) || defined(FUZZING)
 542 bool LoggingEnabledFor(const char* aTopLevelProtocol, const char* aFilter);
 543 #endif
 544
 545 inline bool LoggingEnabledFor(const char* aTopLevelProtocol) {
 546 #if defined(DEBUG) || defined(FUZZING)
 547   return LoggingEnabledFor(aTopLevelProtocol, PR_GetEnv("MOZ_IPC_MESSAGE_LOG"));
 548 #else
 549   return false;
 550 #endif
 551 }
 552
 553 MOZ_NEVER_INLINE void LogMessageForProtocol(const char* aTopLevelProtocol,
 554                                             base::ProcessId aOtherPid,
 555                                             const char* aContextDescription,
 556                                             uint32_t aMessageId,
 557                                             MessageDirection aDirection);
 558
 559 MOZ_NEVER_INLINE void ProtocolErrorBreakpoint(const char* aMsg);
 560
 561 // IPC::MessageReader and IPC::MessageWriter call this function for FatalError
 562 // calls which come from serialization/deserialization.
 563 MOZ_NEVER_INLINE void PickleFatalError(const char* aMsg, IProtocol* aActor);
 564
 565 // The code generator calls this function for errors which come from the
 566 // methods of protocols.  Doing this saves codesize by making the error
 567 // cases significantly smaller.
 568 MOZ_NEVER_INLINE void FatalError(const char* aMsg, bool aIsParent);
 569
 570 // The code generator calls this function for errors which are not
 571 // protocol-specific: errors in generated struct methods or errors in
 572 // transition functions, for instance.  Doing this saves codesize by
 573 // by making the error cases significantly smaller.
 574 MOZ_NEVER_INLINE void LogicError(const char* aMsg);
 575
 576 MOZ_NEVER_INLINE void ActorIdReadError(const char* aActorDescription);
 577
 578 MOZ_NEVER_INLINE void BadActorIdError(const char* aActorDescription);
 579
 580 MOZ_NEVER_INLINE void ActorLookupError(const char* aActorDescription);
 581
 582 MOZ_NEVER_INLINE void MismatchedActorTypeError(const char* aActorDescription);
 583
 584 MOZ_NEVER_INLINE void UnionTypeReadError(const char* aUnionName);
 585
 586 MOZ_NEVER_INLINE void ArrayLengthReadError(const char* aElementName);
 587
 588 MOZ_NEVER_INLINE void SentinelReadError(const char* aElementName);
 589
 590 /**
 591  * Annotate the crash reporter with the error code from the most recent system
 592  * call. Returns the system error.
 593  */
 594 void AnnotateSystemError();
 595
 596 // The ActorLifecycleProxy is a helper type used internally by IPC to maintain a
 597 // maybe-owning reference to an IProtocol object. For well-behaved actors
 598 // which are not freed until after their `Dealloc` method is called, a
 599 // reference to an actor's `ActorLifecycleProxy` object is an owning one, as the
 600 // `Dealloc` method will only be called when all references to the
 601 // `ActorLifecycleProxy` are released.
 602 //
 603 // Unfortunately, some actors may be destroyed before their `Dealloc` method
 604 // is called. For these actors, `ActorLifecycleProxy` acts as a weak pointer,
 605 // and will begin to return `nullptr` from its `Get()` method once the
 606 // corresponding actor object has been destroyed.
 607 //
 608 // When calling a `Recv` method, IPC will hold a `ActorLifecycleProxy` reference
 609 // to the target actor, meaning that well-behaved actors can behave as though a
 610 // strong reference is being held.
 611 //
 612 // Generic IPC code MUST treat ActorLifecycleProxy references as weak
 613 // references!
 614 class ActorLifecycleProxy {
 615  public:
 616   NS_INLINE_DECL_REFCOUNTING_ONEVENTTARGET(ActorLifecycleProxy)
 617
 618   IProtocol* Get() { return mActor; }
 619
 620   WeakActorLifecycleProxy* GetWeakProxy();
 621
 622  private:
 623   friend class IProtocol;
 624
 625   explicit ActorLifecycleProxy(IProtocol* aActor);
 626   ~ActorLifecycleProxy();
 627
 628   ActorLifecycleProxy(const ActorLifecycleProxy&) = delete;
 629   ActorLifecycleProxy& operator=(const ActorLifecycleProxy&) = delete;
 630
 631   IProtocol* MOZ_NON_OWNING_REF mActor;
 632
 633   // Hold a reference to the actor's manager's ActorLifecycleProxy to help
 634   // prevent it from dying while we're still alive!
 635   RefPtr<ActorLifecycleProxy> mManager;
 636
 637   // When requested, the current self-referencing weak reference for this
 638   // ActorLifecycleProxy.
 639   RefPtr<WeakActorLifecycleProxy> mWeakProxy;
 640 };
 641
 642 // Unlike ActorLifecycleProxy, WeakActorLifecycleProxy only holds a weak
 643 // reference to both the proxy and the actual actor, meaning that holding this
 644 // type will not attempt to keep the actor object alive.
 645 //
 646 // This type is safe to hold on threads other than the actor's thread, but is
 647 // _NOT_ safe to access on other threads, as actors and ActorLifecycleProxy
 648 // objects are not threadsafe.
 649 class WeakActorLifecycleProxy final {
 650  public:
 651   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WeakActorLifecycleProxy)
 652
 653   // May only be called on the actor's event target.
 654   // Will return `nullptr` if the actor has already been destroyed from IPC's
 655   // point of view.
 656   IProtocol* Get() const;
 657
 658   // Safe to call on any thread.
 659   nsISerialEventTarget* ActorEventTarget() const { return mActorEventTarget; }
 660
 661  private:
 662   friend class ActorLifecycleProxy;
 663
 664   explicit WeakActorLifecycleProxy(ActorLifecycleProxy* aProxy);
 665   ~WeakActorLifecycleProxy();
 666
 667   WeakActorLifecycleProxy(const WeakActorLifecycleProxy&) = delete;
 668   WeakActorLifecycleProxy& operator=(const WeakActorLifecycleProxy&) = delete;
 669
 670   // This field may only be accessed on the actor's thread, and will be
 671   // automatically cleared when the ActorLifecycleProxy is destroyed.
 672   ActorLifecycleProxy* MOZ_NON_OWNING_REF mProxy;
 673
 674   // The serial event target which owns the actor, and is the only thread where
 675   // it is OK to access the ActorLifecycleProxy.
 676   const nsCOMPtr<nsISerialEventTarget> mActorEventTarget;
 677 };
 678
 679 class IPDLResolverInner final {
 680  public:
 681   NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DESTROY(IPDLResolverInner,
 682                                                      Destroy())
 683
 684   explicit IPDLResolverInner(UniquePtr<IPC::Message> aReply, IProtocol* aActor);
 685
 686   template <typename F>
 687   void Resolve(F&& aWrite) {
 688     ResolveOrReject(true, aWrite);
 689   }
 690
 691  private:
 692   void ResolveOrReject(bool aResolve,
 693                        FunctionRef<void(IPC::Message*, IProtocol*)> aWrite);
 694
 695   void Destroy();
 696   ~IPDLResolverInner();
 697
 698   UniquePtr<IPC::Message> mReply;
 699   RefPtr<WeakActorLifecycleProxy> mWeakProxy;
 700 };
 701
 702 }  // namespace ipc
 703
 704 template <typename Protocol>
 705 class ManagedContainer {
 706  public:
 707   using iterator = typename nsTArray<Protocol*>::const_iterator;
 708
 709   iterator begin() const { return mArray.begin(); }
 710   iterator end() const { return mArray.end(); }
 711   iterator cbegin() const { return begin(); }
 712   iterator cend() const { return end(); }
 713
 714   bool IsEmpty() const { return mArray.IsEmpty(); }
 715   uint32_t Count() const { return mArray.Length(); }
 716
 717   void ToArray(nsTArray<Protocol*>& aArray) const {
 718     aArray.AppendElements(mArray);
 719   }
 720
 721   bool EnsureRemoved(Protocol* aElement) {
 722     return mArray.RemoveElementSorted(aElement);
 723   }
 724
 725   void Insert(Protocol* aElement) {
 726     // Equivalent to `InsertElementSorted`, avoiding inserting a duplicate
 727     // element.
 728     size_t index = mArray.IndexOfFirstElementGt(aElement);
 729     if (index == 0 || mArray[index - 1] != aElement) {
 730       mArray.InsertElementAt(index, aElement);
 731     }
 732   }
 733
 734   void Clear() { mArray.Clear(); }
 735
 736  private:
 737   nsTArray<Protocol*> mArray;
 738 };
 739
 740 template <typename Protocol>
 741 Protocol* LoneManagedOrNullAsserts(
 742     const ManagedContainer<Protocol>& aManagees) {
 743   if (aManagees.IsEmpty()) {
 744     return nullptr;
 745   }
 746   MOZ_ASSERT(aManagees.Count() == 1);
 747   return *aManagees.cbegin();
 748 }
 749
 750 template <typename Protocol>
 751 Protocol* SingleManagedOrNull(const ManagedContainer<Protocol>& aManagees) {
 752   if (aManagees.Count() != 1) {
 753     return nullptr;
 754   }
 755   return *aManagees.cbegin();
 756 }
 757
 758 }  // namespace mozilla
 759
 760 #endif  // mozilla_ipc_ProtocolUtils_h