src/ppapi/proxy/resource_message_params.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef PPAPI_PROXY_RESOURCE_MESSAGE_PARAMS_H_
   6 #define PPAPI_PROXY_RESOURCE_MESSAGE_PARAMS_H_
   7
   8 #include <vector>
   9
  10 #include "base/memory/ref_counted.h"
  11 #include "ipc/ipc_message_utils.h"
  12 #include "ppapi/c/pp_resource.h"
  13 #include "ppapi/proxy/ppapi_proxy_export.h"
  14 #include "ppapi/proxy/serialized_handle.h"
  15
  16 namespace ppapi {
  17 namespace proxy {
  18
  19 // Common parameters for resource call and reply params structures below.
  20 class PPAPI_PROXY_EXPORT ResourceMessageParams {
  21  public:
  22   virtual ~ResourceMessageParams();
  23
  24   PP_Resource pp_resource() const { return pp_resource_; }
  25   int32_t sequence() const { return sequence_; }
  26
  27   // Note that the caller doesn't take ownership of the returned handles.
  28   const std::vector<SerializedHandle>& handles() const {
  29     return handles_->data();
  30   }
  31
  32   // Makes ResourceMessageParams leave its handles open, even if they weren't
  33   // taken using a Take.* function. After this call, no Take.* calls are
  34   // allowed.
  35   void ConsumeHandles() const;
  36
  37   // Returns the handle at the given index if it exists and is of the given
  38   // type. The corresponding slot in the list is set to an invalid handle.
  39   // If the index doesn't exist or the handle isn't of the given type, returns
  40   // an invalid handle.
  41   // Note that the caller is responsible for closing the returned handle, if it
  42   // is valid.
  43   SerializedHandle TakeHandleOfTypeAtIndex(size_t index,
  44                                            SerializedHandle::Type type) const;
  45
  46   // Helper functions to return shared memory, socket or file handles passed in
  47   // the params struct.
  48   // If the index has a valid handle of the given type, it will be placed in the
  49   // output parameter, the corresponding slot in the list will be set to an
  50   // invalid handle, and the function will return true. If the handle doesn't
  51   // exist or is a different type, the functions will return false and the
  52   // output parameter will be untouched.
  53   //
  54   // Note: 1) the handle could still be a "null" or invalid handle of the right
  55   //          type and the functions will succeed.
  56   //       2) the caller is responsible for closing the returned handle, if it
  57   //          is valid.
  58   bool TakeSharedMemoryHandleAtIndex(size_t index,
  59                                      base::SharedMemoryHandle* handle) const;
  60   bool TakeSocketHandleAtIndex(size_t index,
  61                                IPC::PlatformFileForTransit* handle) const;
  62   bool TakeFileHandleAtIndex(size_t index,
  63                              IPC::PlatformFileForTransit* handle) const;
  64   void TakeAllSharedMemoryHandles(
  65       std::vector<base::SharedMemoryHandle>* handles) const;
  66
  67   // Appends the given handle to the list of handles sent with the call or
  68   // reply.
  69   void AppendHandle(const SerializedHandle& handle) const;
  70
  71  protected:
  72   ResourceMessageParams();
  73   ResourceMessageParams(PP_Resource resource, int32_t sequence);
  74
  75   virtual void Serialize(IPC::Message* msg) const;
  76   virtual bool Deserialize(const IPC::Message* msg, PickleIterator* iter);
  77
  78   // Writes everything except the handles to |msg|.
  79   void WriteHeader(IPC::Message* msg) const;
  80   // Writes the handles to |msg|.
  81   void WriteHandles(IPC::Message* msg) const;
  82   // Matching deserialize helpers.
  83   bool ReadHeader(const IPC::Message* msg, PickleIterator* iter);
  84   bool ReadHandles(const IPC::Message* msg, PickleIterator* iter);
  85
  86  private:
  87   class SerializedHandles
  88       : public base::RefCountedThreadSafe<SerializedHandles> {
  89    public:
  90     SerializedHandles();
  91     ~SerializedHandles();
  92
  93     void set_should_close(bool value) { should_close_ = value; }
  94     std::vector<SerializedHandle>& data() { return data_; }
  95
  96    private:
  97     friend class base::RefCountedThreadSafe<SerializedHandles>;
  98
  99     // Whether the handles stored in |data_| should be closed when this object
 100     // goes away.
 101     //
 102     // It is set to true by ResourceMessageParams::Deserialize(), so that the
 103     // receiving side of the params (the host side for
 104     // ResourceMessageCallParams; the plugin side for
 105     // ResourceMessageReplyParams) will close those handles which haven't been
 106     // taken using any of the Take*() methods.
 107     bool should_close_;
 108     std::vector<SerializedHandle> data_;
 109   };
 110
 111   PP_Resource pp_resource_;
 112
 113   // Identifier for this message. Sequence numbers are quasi-unique within a
 114   // resource, but will overlap between different resource objects.
 115   //
 116   // If you send a lot of messages, the ID may wrap around. This is OK. All IDs
 117   // are valid and 0 and -1 aren't special, so those cases won't confuse us.
 118   // In practice, if you send more than 4 billion messages for a resource, the
 119   // old ones will be long gone and there will be no collisions.
 120   //
 121   // If there is a malicious plugin (or exceptionally bad luck) that causes a
 122   // wraparound and collision the worst that will happen is that we can get
 123   // confused between different callbacks. But since these can only cause
 124   // confusion within the plugin and within callbacks on the same resource,
 125   // there shouldn't be a security problem.
 126   int32_t sequence_;
 127
 128   // A list of all handles transferred in the message. Handles go here so that
 129   // the NaCl adapter can extract them generally when it rewrites them to
 130   // go between Windows and NaCl (Posix) apps.
 131   // TODO(yzshen): Mark it as mutable so that we can take/append handles using a
 132   // const reference. We need to change all the callers and make it not mutable.
 133   mutable scoped_refptr<SerializedHandles> handles_;
 134 };
 135
 136 // Parameters common to all ResourceMessage "Call" requests.
 137 class PPAPI_PROXY_EXPORT ResourceMessageCallParams
 138     : public ResourceMessageParams {
 139  public:
 140   ResourceMessageCallParams();
 141   ResourceMessageCallParams(PP_Resource resource, int32_t sequence);
 142   virtual ~ResourceMessageCallParams();
 143
 144   void set_has_callback() { has_callback_ = true; }
 145   bool has_callback() const { return has_callback_; }
 146
 147   virtual void Serialize(IPC::Message* msg) const OVERRIDE;
 148   virtual bool Deserialize(const IPC::Message* msg,
 149                            PickleIterator* iter) OVERRIDE;
 150
 151  private:
 152   bool has_callback_;
 153 };
 154
 155 // Parameters common to all ResourceMessage "Reply" requests.
 156 class PPAPI_PROXY_EXPORT ResourceMessageReplyParams
 157     : public ResourceMessageParams {
 158  public:
 159   ResourceMessageReplyParams();
 160   ResourceMessageReplyParams(PP_Resource resource, int32_t sequence);
 161   virtual ~ResourceMessageReplyParams();
 162
 163   void set_result(int32_t r) { result_ = r; }
 164   int32_t result() const { return result_; }
 165
 166   virtual void Serialize(IPC::Message* msg) const OVERRIDE;
 167   virtual bool Deserialize(const IPC::Message* msg,
 168                            PickleIterator* iter) OVERRIDE;
 169
 170   // Writes everything except the handles to |msg|.
 171   void WriteReplyHeader(IPC::Message* msg) const;
 172
 173  private:
 174   // Pepper "result code" for the callback.
 175   int32_t result_;
 176 };
 177
 178 }  // namespace proxy
 179 }  // namespace ppapi
 180
 181 namespace IPC {
 182
 183 template <> struct PPAPI_PROXY_EXPORT
 184 ParamTraits<ppapi::proxy::ResourceMessageCallParams> {
 185   typedef ppapi::proxy::ResourceMessageCallParams param_type;
 186   static void Write(Message* m, const param_type& p) {
 187     p.Serialize(m);
 188   }
 189   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 190     return r->Deserialize(m, iter);
 191   }
 192   static void Log(const param_type& p, std::string* l) {
 193   }
 194 };
 195
 196 template <> struct PPAPI_PROXY_EXPORT
 197 ParamTraits<ppapi::proxy::ResourceMessageReplyParams> {
 198   typedef ppapi::proxy::ResourceMessageReplyParams param_type;
 199   static void Write(Message* m, const param_type& p) {
 200     p.Serialize(m);
 201   }
 202   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
 203     return r->Deserialize(m, iter);
 204   }
 205   static void Log(const param_type& p, std::string* l) {
 206   }
 207 };
 208
 209 }  // namespace IPC
 210
 211 #endif  // PPAPI_PROXY_RESOURCE_MESSAGE_PARAMS_H_