#ifndef SRC_ENV_H_

#define SRC_ENV_H_

#include "ares.h"

#include "debug-agent.h"

#include "handle_wrap.h"

#include "req-wrap.h"

#include "tree.h"

#include "util.h"

#include "uv.h"

#include "v8.h"

#include <stdint.h>

// Caveat emptor: we're going slightly crazy with macros here but the end

// hopefully justifies the means. We have a lot of per-context properties

// and adding and maintaining their getters and setters by hand would be

// a nightmare so let's make the preprocessor generate them for us.

//

// Make sure that any macros defined here are undefined again at the bottom

// of context-inl.h. The exceptions are NODE_CONTEXT_EMBEDDER_DATA_INDEX

// and NODE_ISOLATE_SLOT, they may have been defined externally.

namespace node {

// Pick an index that's hopefully out of the way when we're embedded inside

// another application. Performance-wise or memory-wise it doesn't matter:

// Context::SetAlignedPointerInEmbedderData() is backed by a FixedArray,

// worst case we pay a one-time penalty for resizing the array.

#ifndef NODE_CONTEXT_EMBEDDER_DATA_INDEX

#define NODE_CONTEXT_EMBEDDER_DATA_INDEX 32

#endif

// The slot 0 and 1 had already been taken by "gin" and "blink" in Chrome,

// and the size of isolate's slots is 4 by default, so using 3 should

// hopefully make node work independently when embedded into other

// application.

#ifndef NODE_ISOLATE_SLOT

#define NODE_ISOLATE_SLOT 3

#endif

// Strings are per-isolate primitives but Environment proxies them

// for the sake of convenience.

#define PER_ISOLATE_STRING_PROPERTIES(V) \

V(address_string, "address") \

V(args_string, "args") \

V(argv_string, "argv") \

V(async, "async") \

V(async_queue_string, "_asyncQueue") \

V(atime_string, "atime") \

V(birthtime_string, "birthtime") \

V(blksize_string, "blksize") \

V(blocks_string, "blocks") \

V(buffer_string, "buffer") \

V(bytes_string, "bytes") \

V(bytes_parsed_string, "bytesParsed") \

V(callback_string, "callback") \

V(change_string, "change") \

V(oncertcb_string, "oncertcb") \

V(onclose_string, "_onclose") \

V(code_string, "code") \

V(compare_string, "compare") \

V(ctime_string, "ctime") \

V(cwd_string, "cwd") \

V(debug_port_string, "debugPort") \

V(debug_string, "debug") \

V(dest_string, "dest") \

V(detached_string, "detached") \

V(dev_string, "dev") \

V(disposed_string, "_disposed") \

V(domain_string, "domain") \

V(domain_abort_uncaught_exc_string, "_makeCallbackAbortOnUncaught") \

V(exchange_string, "exchange") \

V(idle_string, "idle") \

V(irq_string, "irq") \

V(enter_string, "enter") \

V(env_pairs_string, "envPairs") \

V(env_string, "env") \

V(errno_string, "errno") \

V(error_string, "error") \

V(events_string, "_events") \

V(exec_argv_string, "execArgv") \

V(exec_path_string, "execPath") \

V(exiting_string, "_exiting") \

V(exit_code_string, "exitCode") \

V(exit_string, "exit") \

V(expire_string, "expire") \

V(exponent_string, "exponent") \

V(exports_string, "exports") \

V(ext_key_usage_string, "ext_key_usage") \

V(family_string, "family") \

V(fatal_exception_string, "_fatalException") \

V(fd_string, "fd") \

V(file_string, "file") \

V(fingerprint_string, "fingerprint") \

V(flags_string, "flags") \

V(fsevent_string, "FSEvent") \

V(gid_string, "gid") \

V(handle_string, "handle") \

V(heap_total_string, "heapTotal") \

V(heap_used_string, "heapUsed") \

V(hostmaster_string, "hostmaster") \

V(ignore_string, "ignore") \

V(immediate_callback_string, "_immediateCallback") \

V(infoaccess_string, "infoAccess") \

V(inherit_string, "inherit") \

V(ino_string, "ino") \

V(input_string, "input") \

V(internal_string, "internal") \

V(ipv4_string, "IPv4") \

V(ipv6_lc_string, "ipv6") \

V(ipv6_string, "IPv6") \

V(isalive_string, "isAlive") \

V(isclosing_string, "isClosing") \

V(issuer_string, "issuer") \

V(issuercert_string, "issuerCertificate") \

V(kill_signal_string, "killSignal") \

V(mac_string, "mac") \

V(mark_sweep_compact_string, "mark-sweep-compact") \

V(max_buffer_string, "maxBuffer") \

V(message_string, "message") \

V(minttl_string, "minttl") \

V(mode_string, "mode") \

V(model_string, "model") \

V(modulus_string, "modulus") \

V(mtime_string, "mtime") \

V(name_string, "name") \

V(need_imm_cb_string, "_needImmediateCallback") \

V(netmask_string, "netmask") \

V(nice_string, "nice") \

V(nlink_string, "nlink") \

V(nsname_string, "nsname") \

V(ocsp_request_string, "OCSPRequest") \

V(offset_string, "offset") \

V(onchange_string, "onchange") \

V(onclienthello_string, "onclienthello") \

V(oncomplete_string, "oncomplete") \

V(onconnection_string, "onconnection") \

V(ondone_string, "ondone") \

V(onerror_string, "onerror") \

V(onexit_string, "onexit") \

V(onhandshakedone_string, "onhandshakedone") \

V(onhandshakestart_string, "onhandshakestart") \

V(onmessage_string, "onmessage") \

V(onnewsession_string, "onnewsession") \

V(onnewsessiondone_string, "onnewsessiondone") \

V(onocspresponse_string, "onocspresponse") \

V(onread_string, "onread") \

V(onreadstart_string, "onreadstart") \

V(onreadstop_string, "onreadstop") \

V(onselect_string, "onselect") \

V(onshutdown_string, "onshutdown") \

V(onsignal_string, "onsignal") \

V(onstop_string, "onstop") \

V(onwrite_string, "onwrite") \

V(output_string, "output") \

V(order_string, "order") \

V(owner_string, "owner") \

V(parse_error_string, "Parse Error") \

V(path_string, "path") \

V(pbkdf2_error_string, "PBKDF2 Error") \

V(pid_string, "pid") \

V(pipe_string, "pipe") \

V(port_string, "port") \

V(preference_string, "preference") \

V(priority_string, "priority") \

V(processed_string, "processed") \

V(prototype_string, "prototype") \

V(raw_string, "raw") \

V(rdev_string, "rdev") \

V(readable_string, "readable") \

V(received_shutdown_string, "receivedShutdown") \

V(refresh_string, "refresh") \

V(regexp_string, "regexp") \

V(rename_string, "rename") \

V(replacement_string, "replacement") \

V(retry_string, "retry") \

V(rss_string, "rss") \

V(serial_string, "serial") \

V(scavenge_string, "scavenge") \

V(scopeid_string, "scopeid") \

V(sent_shutdown_string, "sentShutdown") \

V(serial_number_string, "serialNumber") \

V(service_string, "service") \

V(servername_string, "servername") \

V(session_id_string, "sessionId") \

V(signal_string, "signal") \

V(size_string, "size") \

V(smalloc_p_string, "_smalloc_p") \

V(sni_context_err_string, "Invalid SNI context") \

V(sni_context_string, "sni_context") \

V(speed_string, "speed") \

V(stack_string, "stack") \

V(status_string, "status") \

V(stdio_string, "stdio") \

V(subject_string, "subject") \

V(subjectaltname_string, "subjectaltname") \

V(sys_string, "sys") \

V(syscall_string, "syscall") \

V(tick_callback_string, "_tickCallback") \

V(tick_domain_cb_string, "_tickDomainCallback") \

V(timeout_string, "timeout") \

V(times_string, "times") \

V(timestamp_string, "timestamp") \

V(title_string, "title") \

V(tls_npn_string, "tls_npn") \

V(tls_ocsp_string, "tls_ocsp") \

V(tls_sni_string, "tls_sni") \

V(tls_string, "tls") \

V(tls_ticket_string, "tlsTicket") \

V(type_string, "type") \

V(uid_string, "uid") \

V(unknown_string, "<unknown>") \

V(user_string, "user") \

V(uv_string, "uv") \

V(valid_from_string, "valid_from") \

V(valid_to_string, "valid_to") \

V(verify_error_string, "verifyError") \

V(version_string, "version") \

V(weight_string, "weight") \

V(windows_verbatim_arguments_string, "windowsVerbatimArguments") \

V(wrap_string, "wrap") \

V(writable_string, "writable") \

V(write_queue_size_string, "writeQueueSize") \

V(x_forwarded_string, "x-forwarded-for") \

V(zero_return_string, "ZERO_RETURN") \

#define ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V) \

V(as_external, v8::External) \

V(async_hooks_init_function, v8::Function) \

V(async_hooks_pre_function, v8::Function) \

V(async_hooks_post_function, v8::Function) \

V(binding_cache_object, v8::Object) \

V(buffer_constructor_function, v8::Function) \

V(context, v8::Context) \

V(domain_array, v8::Array) \

V(fs_stats_constructor_function, v8::Function) \

V(jsstream_constructor_template, v8::FunctionTemplate) \

V(module_load_list_array, v8::Array) \

V(pipe_constructor_template, v8::FunctionTemplate) \

V(process_object, v8::Object) \

V(promise_reject_function, v8::Function) \

V(script_context_constructor_template, v8::FunctionTemplate) \

V(script_data_constructor_function, v8::Function) \

V(secure_context_constructor_template, v8::FunctionTemplate) \

V(tcp_constructor_template, v8::FunctionTemplate) \

V(tick_callback_function, v8::Function) \

V(tls_wrap_constructor_function, v8::Function) \

V(tls_wrap_constructor_template, v8::FunctionTemplate) \

V(tty_constructor_template, v8::FunctionTemplate) \

V(udp_constructor_function, v8::Function) \

V(write_wrap_constructor_function, v8::Function) \

class Environment;

// TODO(bnoordhuis) Rename struct, the ares_ prefix implies it's part

// of the c-ares API while the _t suffix implies it's a typedef.

struct ares_task_t {

Environment* env;

ares_socket_t sock;

uv_poll_t poll_watcher;

RB_ENTRY(ares_task_t) node;

};

RB_HEAD(ares_task_list, ares_task_t);

class Environment {

public:

class AsyncHooks {

public:

inline uint32_t* fields();

inline int fields_count() const;

inline bool callbacks_enabled();

inline void set_enable_callbacks(uint32_t flag);

private:

friend class Environment; // So we can call the constructor.

inline AsyncHooks();

enum Fields {

// Set this to not zero if the init hook should be called.

kEnableCallbacks,

kFieldsCount

};

uint32_t fields_[kFieldsCount];

DISALLOW_COPY_AND_ASSIGN(AsyncHooks);

};

class DomainFlag {

public:

inline uint32_t* fields();

inline int fields_count() const;

inline uint32_t count() const;

private:

friend class Environment; // So we can call the constructor.

inline DomainFlag();

enum Fields {

kCount,

kFieldsCount

};

uint32_t fields_[kFieldsCount];

DISALLOW_COPY_AND_ASSIGN(DomainFlag);

};

class TickInfo {

public:

inline uint32_t* fields();

inline int fields_count() const;

inline bool in_tick() const;

inline bool last_threw() const;

inline uint32_t index() const;

inline uint32_t length() const;

inline void set_in_tick(bool value);

inline void set_index(uint32_t value);

inline void set_last_threw(bool value);

private:

friend class Environment; // So we can call the constructor.

inline TickInfo();

enum Fields {

kIndex,

kLength,

kFieldsCount

};

uint32_t fields_[kFieldsCount];

bool in_tick_;

bool last_threw_;

DISALLOW_COPY_AND_ASSIGN(TickInfo);

};

typedef void (*HandleCleanupCb)(Environment* env,

uv_handle_t* handle,

void* arg);

class HandleCleanup {

private:

friend class Environment;

HandleCleanup(uv_handle_t* handle, HandleCleanupCb cb, void* arg)

: handle_(handle),

cb_(cb),

arg_(arg) {

}

uv_handle_t* handle_;

HandleCleanupCb cb_;

void* arg_;

ListNode<HandleCleanup> handle_cleanup_queue_;

};

static inline Environment* GetCurrent(v8::Isolate* isolate);

static inline Environment* GetCurrent(v8::Local<v8::Context> context);

static inline Environment* GetCurrent(

const v8::FunctionCallbackInfo<v8::Value>& info);

template <typename T>

static inline Environment* GetCurrent(

const v8::PropertyCallbackInfo<T>& info);

// See CreateEnvironment() in src/node.cc.

static inline Environment* New(v8::Local<v8::Context> context,

uv_loop_t* loop);

inline void CleanupHandles();

inline void Dispose();

void AssignToContext(v8::Local<v8::Context> context);

inline v8::Isolate* isolate() const;

inline uv_loop_t* event_loop() const;

inline bool async_wrap_callbacks_enabled() const;

inline bool in_domain() const;

inline uint32_t watched_providers() const;

static inline Environment* from_immediate_check_handle(uv_check_t* handle);

inline uv_check_t* immediate_check_handle();

inline uv_idle_t* immediate_idle_handle();

static inline Environment* from_idle_prepare_handle(uv_prepare_t* handle);

inline uv_prepare_t* idle_prepare_handle();

static inline Environment* from_idle_check_handle(uv_check_t* handle);

inline uv_check_t* idle_check_handle();

// Register clean-up cb to be called on env->Dispose()

inline void RegisterHandleCleanup(uv_handle_t* handle,

HandleCleanupCb cb,

void *arg);

inline void FinishHandleCleanup(uv_handle_t* handle);

inline AsyncHooks* async_hooks();

inline DomainFlag* domain_flag();

inline TickInfo* tick_info();

inline uint64_t timer_base() const;

static inline Environment* from_cares_timer_handle(uv_timer_t* handle);

inline uv_timer_t* cares_timer_handle();

inline ares_channel cares_channel();

inline ares_channel* cares_channel_ptr();

inline ares_task_list* cares_task_list();

inline bool using_smalloc_alloc_cb() const;

inline void set_using_smalloc_alloc_cb(bool value);

inline bool using_abort_on_uncaught_exc() const;

inline void set_using_abort_on_uncaught_exc(bool value);

inline bool using_domains() const;

inline void set_using_domains(bool value);

inline bool using_asyncwrap() const;

inline void set_using_asyncwrap(bool value);

inline bool printed_error() const;

inline void set_printed_error(bool value);

void PrintSyncTrace() const;

inline void set_trace_sync_io(bool value);

inline void ThrowError(const char* errmsg);

inline void ThrowTypeError(const char* errmsg);

inline void ThrowRangeError(const char* errmsg);

inline void ThrowErrnoException(int errorno,

const char* syscall = nullptr,

const char* message = nullptr,

const char* path = nullptr);

inline void ThrowUVException(int errorno,

const char* syscall = nullptr,

const char* message = nullptr,

const char* path = nullptr,

const char* dest = nullptr);

// Convenience methods for contextify

inline static void ThrowError(v8::Isolate* isolate, const char* errmsg);

inline static void ThrowTypeError(v8::Isolate* isolate, const char* errmsg);

inline static void ThrowRangeError(v8::Isolate* isolate, const char* errmsg);

inline v8::Local<v8::FunctionTemplate>

NewFunctionTemplate(v8::FunctionCallback callback,

v8::Local<v8::Signature> signature =

v8::Local<v8::Signature>());

// Convenience methods for NewFunctionTemplate().

inline void SetMethod(v8::Local<v8::Object> that,

const char* name,

v8::FunctionCallback callback);

inline void SetProtoMethod(v8::Local<v8::FunctionTemplate> that,

const char* name,

v8::FunctionCallback callback);

inline void SetTemplateMethod(v8::Local<v8::FunctionTemplate> that,

const char* name,

v8::FunctionCallback callback);

// Strings are shared across shared contexts. The getters simply proxy to

// the per-isolate primitive.

#define V(PropertyName, StringValue) \

inline v8::Local<v8::String> PropertyName() const;

PER_ISOLATE_STRING_PROPERTIES(V)

#undef V

#define V(PropertyName, TypeName) \

inline v8::Local<TypeName> PropertyName() const; \

inline void set_ ## PropertyName(v8::Local<TypeName> value);

ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)

#undef V

inline debugger::Agent* debugger_agent() {

return &debugger_agent_;

}

typedef ListHead<HandleWrap, &HandleWrap::handle_wrap_queue_> HandleWrapQueue;

typedef ListHead<ReqWrap<uv_req_t>, &ReqWrap<uv_req_t>::req_wrap_queue_>

ReqWrapQueue;

inline HandleWrapQueue* handle_wrap_queue() { return &handle_wrap_queue_; }

inline ReqWrapQueue* req_wrap_queue() { return &req_wrap_queue_; }

static const int kContextEmbedderDataIndex = NODE_CONTEXT_EMBEDDER_DATA_INDEX;

private:

static const int kIsolateSlot = NODE_ISOLATE_SLOT;

class IsolateData;

inline Environment(v8::Local<v8::Context> context, uv_loop_t* loop);

inline ~Environment();

inline IsolateData* isolate_data() const;

v8::Isolate* const isolate_;

IsolateData* const isolate_data_;

uv_check_t immediate_check_handle_;

uv_idle_t immediate_idle_handle_;

uv_prepare_t idle_prepare_handle_;

uv_check_t idle_check_handle_;

AsyncHooks async_hooks_;

DomainFlag domain_flag_;

TickInfo tick_info_;

const uint64_t timer_base_;

uv_timer_t cares_timer_handle_;

ares_channel cares_channel_;

ares_task_list cares_task_list_;

bool using_smalloc_alloc_cb_;

bool using_domains_;

bool using_abort_on_uncaught_exc_;

bool using_asyncwrap_;

bool printed_error_;

bool trace_sync_io_;

debugger::Agent debugger_agent_;

HandleWrapQueue handle_wrap_queue_;

ReqWrapQueue req_wrap_queue_;

ListHead<HandleCleanup,

&HandleCleanup::handle_cleanup_queue_> handle_cleanup_queue_;

int handle_cleanup_waiting_;

#define V(PropertyName, TypeName) \

v8::Persistent<TypeName> PropertyName ## _;

ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)

#undef V

// Per-thread, reference-counted singleton.

class IsolateData {

public:

static inline IsolateData* GetOrCreate(v8::Isolate* isolate,

uv_loop_t* loop);

inline void Put();

inline uv_loop_t* event_loop() const;

#define V(PropertyName, StringValue) \

inline v8::Local<v8::String> PropertyName() const;

PER_ISOLATE_STRING_PROPERTIES(V)

#undef V

private:

inline static IsolateData* Get(v8::Isolate* isolate);

inline explicit IsolateData(v8::Isolate* isolate, uv_loop_t* loop);

inline v8::Isolate* isolate() const;

uv_loop_t* const event_loop_;

v8::Isolate* const isolate_;

#define V(PropertyName, StringValue) \

v8::Eternal<v8::String> PropertyName ## _;

PER_ISOLATE_STRING_PROPERTIES(V)

#undef V

unsigned int ref_count_;

DISALLOW_COPY_AND_ASSIGN(IsolateData);

};

DISALLOW_COPY_AND_ASSIGN(Environment);

};

} // namespace node

#endif // SRC_ENV_H_