ipc/glue/ProtocolUtils.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * vim: sw=4 ts=4 et :
   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 #ifndef mozilla_ipc_ProtocolUtils_h
   9 #define mozilla_ipc_ProtocolUtils_h 1
  10
  11 #include "base/process.h"
  12 #include "base/process_util.h"
  13 #include "chrome/common/ipc_message_utils.h"
  14
  15 #include "prenv.h"
  16
  17 #include "IPCMessageStart.h"
  18 #include "mozilla/Attributes.h"
  19 #include "mozilla/ipc/FileDescriptor.h"
  20 #include "mozilla/ipc/Shmem.h"
  21 #include "mozilla/ipc/Transport.h"
  22 #include "mozilla/ipc/MessageLink.h"
  23 #include "mozilla/LinkedList.h"
  24 #include "MainThreadUtils.h"
  25
  26 #if defined(ANDROID) && defined(DEBUG)
  27 #include <android/log.h>
  28 #endif
  29
  30 // WARNING: this takes into account the private, special-message-type
  31 // enum in ipc_channel.h.  They need to be kept in sync.
  32 namespace {
  33 // XXX the max message ID is actually kuint32max now ... when this
  34 // changed, the assumptions of the special message IDs changed in that
  35 // they're not carving out messages from likely-unallocated space, but
  36 // rather carving out messages from the end of space allocated to
  37 // protocol 0.  Oops!  We can get away with this until protocol 0
  38 // starts approaching its 65,536th message.
  39 enum {
  40     CHANNEL_OPENED_MESSAGE_TYPE = kuint16max - 5,
  41     SHMEM_DESTROYED_MESSAGE_TYPE = kuint16max - 4,
  42     SHMEM_CREATED_MESSAGE_TYPE = kuint16max - 3,
  43     GOODBYE_MESSAGE_TYPE       = kuint16max - 2
  44
  45     // kuint16max - 1 is used by ipc_channel.h.
  46 };
  47 }
  48
  49 namespace mozilla {
  50 namespace dom {
  51 class ContentParent;
  52 }
  53
  54 namespace net {
  55 class NeckoParent;
  56 }
  57
  58 namespace ipc {
  59
  60 #ifdef XP_WIN
  61 const base::ProcessHandle kInvalidProcessHandle = INVALID_HANDLE_VALUE;
  62 #else
  63 const base::ProcessHandle kInvalidProcessHandle = -1;
  64 #endif
  65
  66 class ProtocolFdMapping;
  67 class ProtocolCloneContext;
  68
  69 // Used to pass references to protocol actors across the wire.
  70 // Actors created on the parent-side have a positive ID, and actors
  71 // allocated on the child side have a negative ID.
  72 struct ActorHandle
  73 {
  74     int mId;
  75 };
  76
  77 // Used internally to represent a "trigger" that might cause a state
  78 // transition.  Triggers are normalized across parent+child to Send
  79 // and Recv (instead of child-in, child-out, parent-in, parent-out) so
  80 // that they can share the same state machine implementation.  To
  81 // further normalize, |Send| is used for 'call', |Recv| for 'answer'.
  82 struct Trigger
  83 {
  84     enum Action { Send, Recv };
  85
  86     Trigger(Action action, int32_t msg) :
  87         mAction(action),
  88         mMsg(msg)
  89     {}
  90
  91     Action mAction;
  92     int32_t mMsg;
  93 };
  94
  95 class ProtocolCloneContext
  96 {
  97   typedef mozilla::dom::ContentParent ContentParent;
  98   typedef mozilla::net::NeckoParent NeckoParent;
  99
 100   ContentParent* mContentParent;
 101   NeckoParent* mNeckoParent;
 102
 103 public:
 104   ProtocolCloneContext()
 105     : mContentParent(nullptr)
 106     , mNeckoParent(nullptr)
 107   {}
 108
 109   void SetContentParent(ContentParent* aContentParent)
 110   {
 111     mContentParent = aContentParent;
 112   }
 113
 114   ContentParent* GetContentParent() { return mContentParent; }
 115
 116   void SetNeckoParent(NeckoParent* aNeckoParent)
 117   {
 118     mNeckoParent = aNeckoParent;
 119   }
 120
 121   NeckoParent* GetNeckoParent() { return mNeckoParent; }
 122 };
 123
 124 template<class ListenerT>
 125 class /*NS_INTERFACE_CLASS*/ IProtocolManager
 126 {
 127 public:
 128     enum ActorDestroyReason {
 129         FailedConstructor,
 130         Deletion,
 131         AncestorDeletion,
 132         NormalShutdown,
 133         AbnormalShutdown
 134     };
 135
 136     typedef base::ProcessHandle ProcessHandle;
 137
 138     virtual int32_t Register(ListenerT*) = 0;
 139     virtual int32_t RegisterID(ListenerT*, int32_t) = 0;
 140     virtual ListenerT* Lookup(int32_t) = 0;
 141     virtual void Unregister(int32_t) = 0;
 142     virtual void RemoveManagee(int32_t, ListenerT*) = 0;
 143
 144     virtual Shmem::SharedMemory* CreateSharedMemory(
 145         size_t, SharedMemory::SharedMemoryType, bool, int32_t*) = 0;
 146     virtual bool AdoptSharedMemory(Shmem::SharedMemory*, int32_t*) = 0;
 147     virtual Shmem::SharedMemory* LookupSharedMemory(int32_t) = 0;
 148     virtual bool IsTrackingSharedMemory(Shmem::SharedMemory*) = 0;
 149     virtual bool DestroySharedMemory(Shmem&) = 0;
 150
 151     // XXX odd ducks, acknowledged
 152     virtual ProcessHandle OtherProcess() const = 0;
 153     virtual MessageChannel* GetIPCChannel() = 0;
 154
 155     // The implementation of function is generated by code generator.
 156     virtual void CloneManagees(ListenerT* aSource,
 157                                ProtocolCloneContext* aCtx) = 0;
 158 };
 159
 160 typedef IPCMessageStart ProtocolId;
 161
 162 /**
 163  * All RPC protocols should implement this interface.
 164  */
 165 class IProtocol : protected MessageListener
 166 {
 167 public:
 168     /**
 169      * This function is used to clone this protocol actor.
 170      *
 171      * see IProtocol::CloneProtocol()
 172      */
 173     virtual IProtocol*
 174     CloneProtocol(MessageChannel* aChannel,
 175                   ProtocolCloneContext* aCtx) = 0;
 176 };
 177
 178 /**
 179  * All top-level protocols should inherit this class.
 180  *
 181  * IToplevelProtocol tracks all top-level protocol actors created from
 182  * this protocol actor.
 183  */
 184 class IToplevelProtocol : public LinkedListElement<IToplevelProtocol>
 185 {
 186 protected:
 187     explicit IToplevelProtocol(ProtocolId aProtoId)
 188         : mProtocolId(aProtoId)
 189         , mTrans(nullptr)
 190     {
 191         MOZ_ASSERT(NS_IsMainThread() || AllowNonMainThreadUse());
 192     }
 193
 194     ~IToplevelProtocol();
 195
 196     /**
 197      * Add an actor to the list of actors that have been opened by this
 198      * protocol.
 199      */
 200     void AddOpenedActor(IToplevelProtocol* aActor);
 201
 202 public:
 203     void SetTransport(Transport* aTrans)
 204     {
 205         mTrans = aTrans;
 206     }
 207
 208     Transport* GetTransport() const { return mTrans; }
 209
 210     ProtocolId GetProtocolId() const { return mProtocolId; }
 211
 212     /**
 213      * Return first of actors of top level protocols opened by this one.
 214      */
 215     IToplevelProtocol* GetFirstOpenedActors()
 216     {
 217         MOZ_ASSERT(NS_IsMainThread() || AllowNonMainThreadUse());
 218         return mOpenActors.getFirst();
 219     }
 220     const IToplevelProtocol* GetFirstOpenedActors() const
 221     {
 222         MOZ_ASSERT(NS_IsMainThread() || AllowNonMainThreadUse());
 223         return mOpenActors.getFirst();
 224     }
 225
 226     virtual IToplevelProtocol*
 227     CloneToplevel(const InfallibleTArray<ProtocolFdMapping>& aFds,
 228                   base::ProcessHandle aPeerProcess,
 229                   ProtocolCloneContext* aCtx);
 230
 231     void CloneOpenedToplevels(IToplevelProtocol* aTemplate,
 232                               const InfallibleTArray<ProtocolFdMapping>& aFds,
 233                               base::ProcessHandle aPeerProcess,
 234                               ProtocolCloneContext* aCtx);
 235
 236 #ifdef MOZ_IPDL_TESTS
 237     static void SetAllowNonMainThreadUse();
 238 #endif
 239
 240     static bool AllowNonMainThreadUse() {
 241 #ifdef MOZ_IPDL_TESTS
 242         return sAllowNonMainThreadUse;
 243 #else
 244         return false;
 245 #endif
 246     }
 247
 248 private:
 249     LinkedList<IToplevelProtocol> mOpenActors; // All protocol actors opened by this.
 250
 251     ProtocolId mProtocolId;
 252     Transport* mTrans;
 253
 254 #ifdef MOZ_IPDL_TESTS
 255     static bool sAllowNonMainThreadUse;
 256 #endif
 257 };
 258
 259
 260 inline bool
 261 LoggingEnabled()
 262 {
 263 #if defined(DEBUG)
 264     return !!PR_GetEnv("MOZ_IPC_MESSAGE_LOG");
 265 #else
 266     return false;
 267 #endif
 268 }
 269
 270 inline bool
 271 LoggingEnabledFor(const char *aTopLevelProtocol)
 272 {
 273 #if defined(DEBUG)
 274     const char *filter = PR_GetEnv("MOZ_IPC_MESSAGE_LOG");
 275     if (!filter) {
 276         return false;
 277     }
 278     return strcmp(filter, "1") == 0 || strcmp(filter, aTopLevelProtocol) == 0;
 279 #else
 280     return false;
 281 #endif
 282 }
 283
 284 MOZ_NEVER_INLINE void
 285 ProtocolErrorBreakpoint(const char* aMsg);
 286
 287 MOZ_NEVER_INLINE void
 288 FatalError(const char* aProtocolName, const char* aMsg,
 289            base::ProcessHandle aHandle, bool aIsParent);
 290
 291 struct PrivateIPDLInterface {};
 292
 293 bool
 294 Bridge(const PrivateIPDLInterface&,
 295        MessageChannel*, base::ProcessHandle, MessageChannel*, base::ProcessHandle,
 296        ProtocolId, ProtocolId);
 297
 298 bool
 299 Open(const PrivateIPDLInterface&,
 300      MessageChannel*, base::ProcessHandle, Transport::Mode,
 301      ProtocolId, ProtocolId);
 302
 303 bool
 304 UnpackChannelOpened(const PrivateIPDLInterface&,
 305                     const IPC::Message&,
 306                     TransportDescriptor*, base::ProcessId*, ProtocolId*);
 307
 308 } // namespace ipc
 309 } // namespace mozilla
 310
 311
 312 namespace IPC {
 313
 314 template <>
 315 struct ParamTraits<mozilla::ipc::ActorHandle>
 316 {
 317     typedef mozilla::ipc::ActorHandle paramType;
 318
 319     static void Write(Message* aMsg, const paramType& aParam)
 320     {
 321         IPC::WriteParam(aMsg, aParam.mId);
 322     }
 323
 324     static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 325     {
 326         int id;
 327         if (IPC::ReadParam(aMsg, aIter, &id)) {
 328             aResult->mId = id;
 329             return true;
 330         }
 331         return false;
 332     }
 333
 334     static void Log(const paramType& aParam, std::wstring* aLog)
 335     {
 336         aLog->append(StringPrintf(L"(%d)", aParam.mId));
 337     }
 338 };
 339
 340 } // namespace IPC
 341
 342
 343 #endif  // mozilla_ipc_ProtocolUtils_h