File Explorer

1// Copyright 2021 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4 5#ifndef INCLUDE_V8_CONTEXT_H_6#define INCLUDE_V8_CONTEXT_H_7 8#include <stdint.h>9 10#include <vector>11 12#include "v8-data.h"          // NOLINT(build/include_directory)13#include "v8-local-handle.h"  // NOLINT(build/include_directory)14#include "v8-maybe.h"         // NOLINT(build/include_directory)15#include "v8-snapshot.h"      // NOLINT(build/include_directory)16#include "v8config.h"         // NOLINT(build/include_directory)17 18namespace v8 {19 20class Function;21class MicrotaskQueue;22class Object;23class ObjectTemplate;24class Value;25class String;26 27/**28 * A container for extension names.29 */30class V8_EXPORT ExtensionConfiguration {31 public:32  ExtensionConfiguration() : name_count_(0), names_(nullptr) {}33  ExtensionConfiguration(int name_count, const char* names[])34      : name_count_(name_count), names_(names) {}35 36  const char** begin() const { return &names_[0]; }37  const char** end() const { return &names_[name_count_]; }38 39 private:40  const int name_count_;41  const char** names_;42};43 44/**45 * A sandboxed execution context with its own set of built-in objects46 * and functions.47 */48class V8_EXPORT Context : public Data {49 public:50  /**51   * Returns the global proxy object.52   *53   * Global proxy object is a thin wrapper whose prototype points to actual54   * context's global object with the properties like Object, etc. This is done55   * that way for security reasons (for more details see56   * https://wiki.mozilla.org/Gecko:SplitWindow).57   *58   * Please note that changes to global proxy object prototype most probably59   * would break VM---v8 expects only global object as a prototype of global60   * proxy object.61   */62  Local<Object> Global();63 64  /**65   * Detaches the global object from its context before66   * the global object can be reused to create a new context.67   */68  void DetachGlobal();69 70  /**71   * Creates a new context and returns a handle to the newly allocated72   * context.73   *74   * \param isolate The isolate in which to create the context.75   *76   * \param extensions An optional extension configuration containing77   * the extensions to be installed in the newly created context.78   *79   * \param global_template An optional object template from which the80   * global object for the newly created context will be created.81   *82   * \param global_object An optional global object to be reused for83   * the newly created context. This global object must have been84   * created by a previous call to Context::New with the same global85   * template. The state of the global object will be completely reset86   * and only object identify will remain.87   *88   * \param internal_fields_deserializer An optional callback used89   * to deserialize fields set by90   * v8::Object::SetAlignedPointerInInternalField() in wrapper objects91   * from the default context snapshot. It should match the92   * SerializeInternalFieldsCallback() used by93   * v8::SnapshotCreator::SetDefaultContext() when the default context94   * snapshot is created. It does not need to be configured if the default95   * context snapshot contains no wrapper objects with pointer internal96   * fields, or if no custom startup snapshot is configured97   * in the v8::CreateParams used to create the isolate.98   *99   * \param microtask_queue An optional microtask queue used to manage100   * the microtasks created in this context. If not set the per-isolate101   * default microtask queue would be used.102   *103   * \param context_data_deserializer An optional callback used104   * to deserialize embedder data set by105   * v8::Context::SetAlignedPointerInEmbedderData() in the default106   * context from the default context snapshot. It does not need to be107   * configured if the default context snapshot contains no pointer embedder108   * data, or if no custom startup snapshot is configured in the109   * v8::CreateParams used to create the isolate.110   *111   * \param api_wrapper_deserializer An optional callback used to deserialize112   * API wrapper objects that was initially set with v8::Object::Wrap() and then113   * serialized using SerializeAPIWrapperCallback.114   */115  static Local<Context> New(116      Isolate* isolate, ExtensionConfiguration* extensions = nullptr,117      MaybeLocal<ObjectTemplate> global_template = MaybeLocal<ObjectTemplate>(),118      MaybeLocal<Value> global_object = MaybeLocal<Value>(),119      DeserializeInternalFieldsCallback internal_fields_deserializer =120          DeserializeInternalFieldsCallback(),121      MicrotaskQueue* microtask_queue = nullptr,122      DeserializeContextDataCallback context_data_deserializer =123          DeserializeContextDataCallback(),124      DeserializeAPIWrapperCallback api_wrapper_deserializer =125          DeserializeAPIWrapperCallback());126 127  /**128   * Create a new context from a (non-default) context snapshot. There129   * is no way to provide a global object template since we do not create130   * a new global object from template, but we can reuse a global object.131   *132   * \param isolate See v8::Context::New().133   *134   * \param context_snapshot_index The index of the context snapshot to135   * deserialize from. Use v8::Context::New() for the default snapshot.136   *137   * \param internal_fields_deserializer An optional callback used138   * to deserialize fields set by139   * v8::Object::SetAlignedPointerInInternalField() in wrapper objects140   * from the default context snapshot. It does not need to be141   * configured if there are no wrapper objects with no internal142   * pointer fields in the default context snapshot or if no startup143   * snapshot is configured when the isolate is created.144   *145   * \param extensions See v8::Context::New().146   *147   * \param global_object See v8::Context::New().148   *149   * \param internal_fields_deserializer Similar to150   * internal_fields_deserializer in v8::Context::New() but applies to151   * the context specified by the context_snapshot_index.152   *153   * \param microtask_queue  See v8::Context::New().154   *155   * \param context_data_deserializer  Similar to156   * context_data_deserializer in v8::Context::New() but applies to157   * the context specified by the context_snapshot_index.158   *159   *\param api_wrapper_deserializer Similar to api_wrapper_deserializer in160   * v8::Context::New() but applies to the context specified by the161   * context_snapshot_index.162   */163  static MaybeLocal<Context> FromSnapshot(164      Isolate* isolate, size_t context_snapshot_index,165      DeserializeInternalFieldsCallback internal_fields_deserializer =166          DeserializeInternalFieldsCallback(),167      ExtensionConfiguration* extensions = nullptr,168      MaybeLocal<Value> global_object = MaybeLocal<Value>(),169      MicrotaskQueue* microtask_queue = nullptr,170      DeserializeContextDataCallback context_data_deserializer =171          DeserializeContextDataCallback(),172      DeserializeAPIWrapperCallback api_wrapper_deserializer =173          DeserializeAPIWrapperCallback());174 175  /**176   * Returns an global object that isn't backed by an actual context.177   *178   * The global template needs to have access checks with handlers installed.179   * If an existing global object is passed in, the global object is detached180   * from its context.181   *182   * Note that this is different from a detached context where all accesses to183   * the global proxy will fail. Instead, the access check handlers are invoked.184   *185   * It is also not possible to detach an object returned by this method.186   * Instead, the access check handlers need to return nothing to achieve the187   * same effect.188   *189   * It is possible, however, to create a new context from the global object190   * returned by this method.191   */192  static MaybeLocal<Object> NewRemoteContext(193      Isolate* isolate, Local<ObjectTemplate> global_template,194      MaybeLocal<Value> global_object = MaybeLocal<Value>());195 196  /**197   * Sets the security token for the context.  To access an object in198   * another context, the security tokens must match.199   */200  void SetSecurityToken(Local<Value> token);201 202  /** Restores the security token to the default value. */203  void UseDefaultSecurityToken();204 205  /** Returns the security token of this context.*/206  Local<Value> GetSecurityToken();207 208  /**209   * Enter this context.  After entering a context, all code compiled210   * and run is compiled and run in this context.  If another context211   * is already entered, this old context is saved so it can be212   * restored when the new context is exited.213   */214  void Enter();215 216  /**217   * Exit this context.  Exiting the current context restores the218   * context that was in place when entering the current context.219   */220  void Exit();221 222  /**223   * Delegate to help with Deep freezing embedder-specific objects (such as224   * JSApiObjects) that can not be frozen natively.225   */226  class DeepFreezeDelegate {227   public:228    /**229     * Performs embedder-specific operations to freeze the provided embedder230     * object. The provided object *will* be frozen by DeepFreeze after this231     * function returns, so only embedder-specific objects need to be frozen.232     * This function *may not* create new JS objects or perform JS allocations.233     * Any v8 objects reachable from the provided embedder object that should234     * also be considered for freezing should be added to the children_out235     * parameter. Returns true if the operation completed successfully.236     */237    virtual bool FreezeEmbedderObjectAndGetChildren(238        Local<Object> obj, LocalVector<Object>& children_out) = 0;239  };240 241  /**242   * Attempts to recursively freeze all objects reachable from this context.243   * Some objects (generators, iterators, non-const closures) can not be frozen244   * and will cause this method to throw an error. An optional delegate can be245   * provided to help freeze embedder-specific objects.246   *247   * Freezing occurs in two steps:248   * 1. "Marking" where we iterate through all objects reachable by this249   *    context, accumulating a list of objects that need to be frozen and250   *    looking for objects that can't be frozen. This step is separated because251   *    it is more efficient when we can assume there is no garbage collection.252   * 2. "Freezing" where we go through the list of objects and freezing them.253   *    This effectively requires copying them so it may trigger garbage254   *    collection.255   */256  Maybe<void> DeepFreeze(DeepFreezeDelegate* delegate = nullptr);257 258  /** Returns the isolate associated with a current context. */259  Isolate* GetIsolate();260 261  /** Returns the microtask queue associated with a current context. */262  MicrotaskQueue* GetMicrotaskQueue();263 264  /** Sets the microtask queue associated with the current context. */265  void SetMicrotaskQueue(MicrotaskQueue* queue);266 267  /**268   * The field at kDebugIdIndex used to be reserved for the inspector.269   * It now serves no purpose.270   */271  enum EmbedderDataFields { kDebugIdIndex = 0 };272 273  /**274   * Return the number of fields allocated for embedder data.275   */276  uint32_t GetNumberOfEmbedderDataFields();277 278  /**279   * Gets the embedder data with the given index, which must have been set by a280   * previous call to SetEmbedderData with the same index.281   */282  V8_INLINE Local<Value> GetEmbedderData(int index);283 284  /**285   * Gets the binding object used by V8 extras. Extra natives get a reference286   * to this object and can use it to "export" functionality by adding287   * properties. Extra natives can also "import" functionality by accessing288   * properties added by the embedder using the V8 API.289   */290  Local<Object> GetExtrasBindingObject();291 292  /**293   * Sets the embedder data with the given index, growing the data as294   * needed. Note that index 0 currently has a special meaning for Chrome's295   * debugger.296   */297  void SetEmbedderData(int index, Local<Value> value);298 299  /**300   * Gets a 2-byte-aligned native pointer from the embedder data with the given301   * index, which must have been set by a previous call to302   * SetAlignedPointerInEmbedderData with the same index. Note that index 0303   * currently has a special meaning for Chrome's debugger.304   */305  V8_INLINE void* GetAlignedPointerFromEmbedderData(Isolate* isolate,306                                                    int index);307  V8_INLINE void* GetAlignedPointerFromEmbedderData(int index);308 309  /**310   * Sets a 2-byte-aligned native pointer in the embedder data with the given311   * index, growing the data as needed. Note that index 0 currently has a312   * special meaning for Chrome's debugger.313   */314  void SetAlignedPointerInEmbedderData(int index, void* value);315 316  /**317   * Control whether code generation from strings is allowed. Calling318   * this method with false will disable 'eval' and the 'Function'319   * constructor for code running in this context. If 'eval' or the320   * 'Function' constructor are used an exception will be thrown.321   *322   * If code generation from strings is not allowed the323   * V8::ModifyCodeGenerationFromStringsCallback callback will be invoked if324   * set before blocking the call to 'eval' or the 'Function'325   * constructor. If that callback returns true, the call will be326   * allowed, otherwise an exception will be thrown. If no callback is327   * set an exception will be thrown.328   */329  void AllowCodeGenerationFromStrings(bool allow);330 331  /**332   * Returns true if code generation from strings is allowed for the context.333   * For more details see AllowCodeGenerationFromStrings(bool) documentation.334   */335  bool IsCodeGenerationFromStringsAllowed() const;336 337  /**338   * Sets the error description for the exception that is thrown when339   * code generation from strings is not allowed and 'eval' or the 'Function'340   * constructor are called.341   */342  void SetErrorMessageForCodeGenerationFromStrings(Local<String> message);343 344  /**345   * Sets the error description for the exception that is thrown when346   * wasm code generation is not allowed.347   */348  void SetErrorMessageForWasmCodeGeneration(Local<String> message);349 350  /**351   * Return data that was previously attached to the context snapshot via352   * SnapshotCreator, and removes the reference to it.353   * Repeated call with the same index returns an empty MaybeLocal.354   */355  template <class T>356  V8_INLINE MaybeLocal<T> GetDataFromSnapshotOnce(size_t index);357 358  /**359   * If callback is set, abort any attempt to execute JavaScript in this360   * context, call the specified callback, and throw an exception.361   * To unset abort, pass nullptr as callback.362   */363  using AbortScriptExecutionCallback = void (*)(Isolate* isolate,364                                                Local<Context> context);365  void SetAbortScriptExecution(AbortScriptExecutionCallback callback);366 367  /**368   * Set or clear hooks to be invoked for promise lifecycle operations.369   * To clear a hook, set it to an empty v8::Function. Each function will370   * receive the observed promise as the first argument. If a chaining371   * operation is used on a promise, the init will additionally receive372   * the parent promise as the second argument.373   */374  void SetPromiseHooks(Local<Function> init_hook, Local<Function> before_hook,375                       Local<Function> after_hook,376                       Local<Function> resolve_hook);377 378  bool HasTemplateLiteralObject(Local<Value> object);379  /**380   * Stack-allocated class which sets the execution context for all381   * operations executed within a local scope.382   */383  class V8_NODISCARD Scope {384   public:385    explicit V8_INLINE Scope(Local<Context> context) : context_(context) {386      context_->Enter();387    }388    V8_INLINE ~Scope() { context_->Exit(); }389 390   private:391    Local<Context> context_;392  };393 394  /**395   * Stack-allocated class to support the backup incumbent settings object396   * stack.397   * https://html.spec.whatwg.org/multipage/webappapis.html#backup-incumbent-settings-object-stack398   */399  class V8_EXPORT V8_NODISCARD BackupIncumbentScope final {400   public:401    /**402     * |backup_incumbent_context| is pushed onto the backup incumbent settings403     * object stack.404     */405    explicit BackupIncumbentScope(Local<Context> backup_incumbent_context);406    ~BackupIncumbentScope();407 408   private:409    friend class internal::Isolate;410 411    uintptr_t JSStackComparableAddressPrivate() const {412      return js_stack_comparable_address_;413    }414 415    Local<Context> backup_incumbent_context_;416    uintptr_t js_stack_comparable_address_ = 0;417    const BackupIncumbentScope* prev_ = nullptr;418  };419 420  V8_INLINE static Context* Cast(Data* data);421 422 private:423  friend class Value;424  friend class Script;425  friend class Object;426  friend class Function;427 428  static void CheckCast(Data* obj);429 430  internal::ValueHelper::InternalRepresentationType GetDataFromSnapshotOnce(431      size_t index);432  Local<Value> SlowGetEmbedderData(int index);433  void* SlowGetAlignedPointerFromEmbedderData(int index);434};435 436// --- Implementation ---437 438Local<Value> Context::GetEmbedderData(int index) {439#ifndef V8_ENABLE_CHECKS440  using A = internal::Address;441  using I = internal::Internals;442  A ctx = internal::ValueHelper::ValueAsAddress(this);443  A embedder_data =444      I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);445  int value_offset =446      I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index);447  A value = I::ReadRawField<A>(embedder_data, value_offset);448#ifdef V8_COMPRESS_POINTERS449  // We read the full pointer value and then decompress it in order to avoid450  // dealing with potential endiannes issues.451  value = I::DecompressTaggedField(embedder_data, static_cast<uint32_t>(value));452#endif453 454  auto isolate = reinterpret_cast<v8::Isolate*>(455      internal::IsolateFromNeverReadOnlySpaceObject(ctx));456  return Local<Value>::New(isolate, value);457#else458  return SlowGetEmbedderData(index);459#endif460}461 462void* Context::GetAlignedPointerFromEmbedderData(Isolate* isolate, int index) {463#if !defined(V8_ENABLE_CHECKS)464  using A = internal::Address;465  using I = internal::Internals;466  A ctx = internal::ValueHelper::ValueAsAddress(this);467  A embedder_data =468      I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);469  int value_offset = I::kEmbedderDataArrayHeaderSize +470                     (I::kEmbedderDataSlotSize * index) +471                     I::kEmbedderDataSlotExternalPointerOffset;472  return reinterpret_cast<void*>(473      I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(474          isolate, embedder_data, value_offset));475#else476  return SlowGetAlignedPointerFromEmbedderData(index);477#endif478}479 480void* Context::GetAlignedPointerFromEmbedderData(int index) {481#if !defined(V8_ENABLE_CHECKS)482  using A = internal::Address;483  using I = internal::Internals;484  A ctx = internal::ValueHelper::ValueAsAddress(this);485  A embedder_data =486      I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);487  int value_offset = I::kEmbedderDataArrayHeaderSize +488                     (I::kEmbedderDataSlotSize * index) +489                     I::kEmbedderDataSlotExternalPointerOffset;490  Isolate* isolate = I::GetIsolateForSandbox(ctx);491  return reinterpret_cast<void*>(492      I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(493          isolate, embedder_data, value_offset));494#else495  return SlowGetAlignedPointerFromEmbedderData(index);496#endif497}498 499template <class T>500MaybeLocal<T> Context::GetDataFromSnapshotOnce(size_t index) {501  if (auto repr = GetDataFromSnapshotOnce(index);502      repr != internal::ValueHelper::kEmpty) {503    internal::PerformCastCheck(internal::ValueHelper::ReprAsValue<T>(repr));504    return Local<T>::FromRepr(repr);505  }506  return {};507}508 509Context* Context::Cast(v8::Data* data) {510#ifdef V8_ENABLE_CHECKS511  CheckCast(data);512#endif513  return static_cast<Context*>(data);514}515 516}  // namespace v8517 518#endif  // INCLUDE_V8_CONTEXT_H_519