frida 16.7.14 → 16.7.15

package/src/device.h

@@ -1,56 +0,0 @@
-#ifndef FRIDANODE_DEVICE_H
-#define FRIDANODE_DEVICE_H
-
-#include "glib_object.h"
-
-#include <frida-core.h>
-
-namespace frida {
-
-class Device : public GLibObject {
- public:
-  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
-  static v8::Local<v8::Object> New(gpointer handle, Runtime* runtime);
-
- private:
-  Device(FridaDevice* handle, Runtime* runtime);
-  ~Device();
-
-  static NAN_METHOD(New);
-
-  static NAN_PROPERTY_GETTER(GetId);
-  static NAN_PROPERTY_GETTER(GetName);
-  static NAN_PROPERTY_GETTER(GetIcon);
-  static NAN_PROPERTY_GETTER(GetType);
-  static NAN_PROPERTY_GETTER(GetBus);
-  static NAN_PROPERTY_GETTER(IsLost);
-
-  static NAN_METHOD(QuerySystemParameters);
-  static NAN_METHOD(GetFrontmostApplication);
-  static NAN_METHOD(EnumerateApplications);
-  static NAN_METHOD(EnumerateProcesses);
-  static NAN_METHOD(EnableSpawnGating);
-  static NAN_METHOD(DisableSpawnGating);
-  static NAN_METHOD(EnumeratePendingSpawn);
-  static NAN_METHOD(EnumeratePendingChildren);
-  static NAN_METHOD(Spawn);
-  static NAN_METHOD(Input);
-  static NAN_METHOD(Resume);
-  static NAN_METHOD(Kill);
-  static NAN_METHOD(Attach);
-  static NAN_METHOD(InjectLibraryFile);
-  static NAN_METHOD(InjectLibraryBlob);
-  static NAN_METHOD(OpenChannel);
-  static NAN_METHOD(OpenService);
-  static NAN_METHOD(Unpair);
-
-  static v8::Local<v8::Value> TransformSignal(const gchar* name, guint index,
-      const GValue* value, gpointer user_data);
-  static void OnConnect(const gchar* signal, gpointer user_data);
-  static void OnDisconnect(const gchar* signal, gpointer user_data);
-  static bool ShouldStayAliveToEmit(const gchar* signal);
-};
-
-}
-
-#endif

package/src/device_manager.cc

@@ -1,362 +0,0 @@
-#include "device_manager.h"
-
-#include "device.h"
-#include "operation.h"
-#include "signals.h"
-
-#include <cstring>
-
-#define DEVICE_MANAGER_DATA_WRAPPERS "device_manager:wrappers"
-
-using std::strcmp;
-using v8::Array;
-using v8::Isolate;
-using v8::Local;
-using v8::Object;
-using v8::String;
-using v8::Value;
-
-namespace frida {
-
-DeviceManager::DeviceManager(FridaDeviceManager* handle, Runtime* runtime)
-    : GLibObject(handle, runtime) {
-  g_object_ref(handle_);
-
-  runtime_->SetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS, g_slist_prepend(
-      static_cast<GSList*>(
-      runtime_->GetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS)), this));
-}
-
-DeviceManager::~DeviceManager() {
-  runtime_->SetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS, g_slist_remove(
-      static_cast<GSList*>(
-      runtime_->GetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS)), this));
-
-  frida_unref(handle_);
-}
-
-void DeviceManager::Init(Local<Object> exports, Runtime* runtime) {
-  Local<String> name = Nan::New("DeviceManager").ToLocalChecked();
-
-  auto tpl = CreateTemplate(name, DeviceManager::New, runtime);
-
-  Nan::SetPrototypeMethod(tpl, "close", Close);
-  Nan::SetPrototypeMethod(tpl, "enumerateDevices", EnumerateDevices);
-  Nan::SetPrototypeMethod(tpl, "addRemoteDevice", AddRemoteDevice);
-  Nan::SetPrototypeMethod(tpl, "removeRemoteDevice", RemoveRemoteDevice);
-
-  Nan::Set(exports, name, Nan::GetFunction(tpl).ToLocalChecked());
-}
-
-void DeviceManager::Dispose(Runtime* runtime) {
-  auto wrappers = static_cast<GSList*>(
-      runtime->GetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS));
-  while (wrappers != NULL) {
-    auto wrapper = static_cast<DeviceManager*>(wrappers->data);
-    frida_device_manager_close_sync(wrapper->GetHandle<FridaDeviceManager>(),
-        NULL, NULL);
-    wrappers = g_slist_delete_link(wrappers, wrappers);
-  }
-  runtime->SetDataPointer(DEVICE_MANAGER_DATA_WRAPPERS, NULL);
-}
-
-NAN_METHOD(DeviceManager::New) {
-  if (!info.IsConstructCall()) {
-    Nan::ThrowError("Use the `new` keyword to create a new instance");
-    return;
-  }
-
-  auto runtime = GetRuntimeFromConstructorArgs(info);
-
-  auto handle = frida_device_manager_new();
-
-  auto wrapper = new DeviceManager(handle, runtime);
-  auto obj = info.This();
-  wrapper->Wrap(obj);
-
-  auto signals_obj = Signals::New(handle, runtime, TransformDeviceSignals,
-      runtime);
-  Nan::Set(obj, Nan::New("signals").ToLocalChecked(), signals_obj);
-
-  g_object_unref(handle);
-
-  auto signals_wrapper = ObjectWrap::Unwrap<Signals>(signals_obj);
-  signals_wrapper->SetConnectCallback(OnConnect, runtime);
-  signals_wrapper->SetDisconnectCallback(OnDisconnect, runtime);
-
-  info.GetReturnValue().Set(obj);
-}
-
-namespace {
-
-class CloseOperation : public Operation<FridaDeviceManager> {
- protected:
-  void Begin() {
-    frida_device_manager_close(handle_, cancellable_, OnReady, this);
-  }
-
-  void End(GAsyncResult* result, GError** error) {
-    frida_device_manager_close_finish(handle_, result, error);
-  }
-
-  Local<Value> Result(Isolate* isolate) {
-    return Nan::Undefined();
-  }
-};
-
-}
-
-NAN_METHOD(DeviceManager::Close) {
-  auto isolate = info.GetIsolate();
-  auto wrapper = ObjectWrap::Unwrap<DeviceManager>(info.Holder());
-
-  auto operation = new CloseOperation();
-  operation->Schedule(isolate, wrapper, info);
-
-  info.GetReturnValue().Set(operation->GetPromise(isolate));
-}
-
-namespace {
-
-class EnumerateDevicesOperation : public Operation<FridaDeviceManager> {
- protected:
-  void Begin() {
-    frida_device_manager_enumerate_devices(handle_, cancellable_, OnReady,
-        this);
-  }
-
-  void End(GAsyncResult* result, GError** error) {
-    devices_ = frida_device_manager_enumerate_devices_finish(handle_, result,
-        error);
-  }
-
-  Local<Value> Result(Isolate* isolate) {
-    auto size = frida_device_list_size(devices_);
-    Local<Array> devices = Nan::New<Array>(size);
-    for (auto i = 0; i != size; i++) {
-      auto handle = frida_device_list_get(devices_, i);
-      auto device = Device::New(handle, runtime_);
-      Nan::Set(devices, i, device);
-      g_object_unref(handle);
-    }
-
-    frida_unref(devices_);
-
-    return devices;
-  }
-
- private:
-  FridaDeviceList* devices_;
-};
-
-}
-
-NAN_METHOD(DeviceManager::EnumerateDevices) {
-  auto isolate = info.GetIsolate();
-  auto wrapper = ObjectWrap::Unwrap<DeviceManager>(info.Holder());
-
-  auto operation = new EnumerateDevicesOperation();
-  operation->Schedule(isolate, wrapper, info);
-
-  info.GetReturnValue().Set(operation->GetPromise(isolate));
-}
-
-namespace {
-
-class AddRemoteDeviceOperation : public Operation<FridaDeviceManager> {
- public:
-  AddRemoteDeviceOperation(gchar* address, FridaRemoteDeviceOptions* options)
-    : address_(address),
-      options_(options) {
-  }
-
-  ~AddRemoteDeviceOperation() {
-    g_object_unref(options_);
-    g_free(address_);
-  }
-
- protected:
-  void Begin() {
-    frida_device_manager_add_remote_device(handle_, address_, options_,
-        cancellable_, OnReady, this);
-  }
-
-  void End(GAsyncResult* result, GError** error) {
-    device_ = frida_device_manager_add_remote_device_finish(handle_, result,
-        error);
-  }
-
-  Local<Value> Result(Isolate* isolate) {
-    auto wrapper = Device::New(device_, runtime_);
-    g_object_unref(device_);
-    return wrapper;
-  }
-
- private:
-  gchar* address_;
-  FridaRemoteDeviceOptions* options_;
-  FridaDevice* device_;
-};
-
-}
-
-NAN_METHOD(DeviceManager::AddRemoteDevice) {
-  auto isolate = info.GetIsolate();
-  auto wrapper = ObjectWrap::Unwrap<DeviceManager>(info.Holder());
-
-  if (info.Length() < 5) {
-    Nan::ThrowTypeError("Missing one or more arguments");
-    return;
-  }
-
-  auto address_value = info[0];
-  auto certificate_value = info[1];
-  auto origin_value = info[2];
-  auto token_value = info[3];
-  auto keepalive_interval_value = info[4];
-
-  if (!address_value->IsString()) {
-    Nan::ThrowTypeError("Bad argument, 'address' must be a string");
-    return;
-  }
-  Nan::Utf8String address(address_value);
-
-  auto options = frida_remote_device_options_new();
-  bool valid = true;
-
-  if (!certificate_value->IsNull()) {
-    GTlsCertificate* certificate;
-    valid = Runtime::ValueToCertificate(certificate_value, &certificate);
-    if (valid) {
-      frida_remote_device_options_set_certificate(options, certificate);
-      g_object_unref(certificate);
-    }
-  }
-
-  if (valid && !origin_value->IsNull()) {
-    if (origin_value->IsString()) {
-      Nan::Utf8String origin(origin_value);
-      frida_remote_device_options_set_origin(options, *origin);
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'origin' must be a string");
-      valid = false;
-    }
-  }
-
-  if (valid && !token_value->IsNull()) {
-    if (token_value->IsString()) {
-      Nan::Utf8String token(token_value);
-      frida_remote_device_options_set_token(options, *token);
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'token' must be a string");
-      valid = false;
-    }
-  }
-
-  if (valid && !keepalive_interval_value->IsNull()) {
-    if (keepalive_interval_value->IsNumber()) {
-      auto keepalive_interval =
-          Nan::To<int32_t>(keepalive_interval_value).FromMaybe(-1);
-      if (keepalive_interval >= -1) {
-        frida_remote_device_options_set_keepalive_interval(options,
-            keepalive_interval);
-      } else {
-        Nan::ThrowTypeError("Bad argument, invalid 'keepaliveInterval'");
-        valid = false;
-      }
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'keepaliveInterval' must be a number");
-      valid = false;
-    }
-  }
-
-  if (!valid) {
-    g_object_unref(options);
-    return;
-  }
-
-  auto operation = new AddRemoteDeviceOperation(g_strdup(*address), options);
-  operation->Schedule(isolate, wrapper, info);
-
-  info.GetReturnValue().Set(operation->GetPromise(isolate));
-}
-
-namespace {
-
-class RemoveRemoteDeviceOperation : public Operation<FridaDeviceManager> {
- public:
-  RemoveRemoteDeviceOperation(gchar* address) : address_(address) {
-  }
-
-  ~RemoveRemoteDeviceOperation() {
-    g_free(address_);
-  }
-
- protected:
-  void Begin() {
-    frida_device_manager_remove_remote_device(handle_, address_, cancellable_,
-        OnReady, this);
-  }
-
-  void End(GAsyncResult* result, GError** error) {
-    frida_device_manager_remove_remote_device_finish(handle_, result, error);
-  }
-
-  Local<Value> Result(Isolate* isolate) {
-    return Nan::Undefined();
-  }
-
- private:
-  gchar* address_;
-};
-
-}
-
-NAN_METHOD(DeviceManager::RemoveRemoteDevice) {
-  auto isolate = info.GetIsolate();
-  auto wrapper = ObjectWrap::Unwrap<DeviceManager>(info.Holder());
-
-  if (info.Length() < 1 || !info[0]->IsString()) {
-    Nan::ThrowTypeError("Expected an address");
-    return;
-  }
-
-  Nan::Utf8String address(info[0]);
-
-  auto operation = new RemoveRemoteDeviceOperation(g_strdup(*address));
-  operation->Schedule(isolate, wrapper, info);
-
-  info.GetReturnValue().Set(operation->GetPromise(isolate));
-}
-
-Local<Value> DeviceManager::TransformDeviceSignals(const gchar* name,
-    guint index, const GValue* value, gpointer user_data) {
-  if (index == 0 && (strcmp(name, "added") == 0 ||
-      strcmp(name, "removed") == 0)) {
-    auto runtime = static_cast<Runtime*>(user_data);
-    return Device::New(g_value_get_object(value), runtime);
-  }
-  return Local<Value>();
-}
-
-void DeviceManager::OnConnect(const gchar* name, gpointer user_data) {
-  auto runtime = static_cast<Runtime*>(user_data);
-
-  if (ShouldStayAliveToEmit(name))
-    runtime->GetUVContext()->IncreaseUsage();
-}
-
-void DeviceManager::OnDisconnect(const gchar* name, gpointer user_data) {
-  auto runtime = static_cast<Runtime*>(user_data);
-
-  if (ShouldStayAliveToEmit(name))
-    runtime->GetUVContext()->DecreaseUsage();
-}
-
-bool DeviceManager::ShouldStayAliveToEmit(const gchar* name) {
-  return strcmp(name, "added") == 0 ||
-      strcmp(name, "removed") == 0 ||
-      strcmp(name, "changed") == 0;
-}
-
-}

package/src/device_manager.h

@@ -1,35 +0,0 @@
-#ifndef FRIDANODE_DEVICE_MANAGER_H
-#define FRIDANODE_DEVICE_MANAGER_H
-
-#include "glib_object.h"
-
-#include <frida-core.h>
-
-namespace frida {
-
-class DeviceManager : public GLibObject {
- public:
-  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
-  static void Dispose(Runtime* runtime);
-
- private:
-  DeviceManager(FridaDeviceManager* handle, Runtime* runtime);
-  ~DeviceManager();
-
-  static NAN_METHOD(New);
-
-  static NAN_METHOD(Close);
-  static NAN_METHOD(EnumerateDevices);
-  static NAN_METHOD(AddRemoteDevice);
-  static NAN_METHOD(RemoveRemoteDevice);
-
-  static v8::Local<v8::Value> TransformDeviceSignals(const gchar* name,
-      guint index, const GValue* value, gpointer user_data);
-  static void OnConnect(const gchar* signal, gpointer user_data);
-  static void OnDisconnect(const gchar* signal, gpointer user_data);
-  static bool ShouldStayAliveToEmit(const gchar* signal);
-};
-
-}
-
-#endif

package/src/endpoint_parameters.cc

@@ -1,171 +0,0 @@
-#include "endpoint_parameters.h"
-
-#include "authentication.h"
-
-#define ENDPOINT_PARAMETERS_DATA_TEMPLATE "endpoint_parameters:tpl"
-
-using v8::Function;
-using v8::FunctionTemplate;
-using v8::Isolate;
-using v8::Local;
-using v8::Object;
-using v8::Persistent;
-using v8::Value;
-
-namespace frida {
-
-EndpointParameters::EndpointParameters(FridaEndpointParameters* handle,
-    Runtime* runtime)
-    : GLibObject(handle, runtime) {
-  g_object_ref(handle_);
-}
-
-EndpointParameters::~EndpointParameters() {
-  g_object_unref(handle_);
-}
-
-void EndpointParameters::Init(Local<Object> exports, Runtime* runtime) {
-  auto isolate = Isolate::GetCurrent();
-
-  auto name = Nan::New("EndpointParameters").ToLocalChecked();
-  auto tpl = CreateTemplate(name, EndpointParameters::New, runtime);
-
-  auto ctor = Nan::GetFunction(tpl).ToLocalChecked();
-  Nan::Set(exports, name, ctor);
-  runtime->SetDataPointer(ENDPOINT_PARAMETERS_DATA_TEMPLATE,
-      new Persistent<FunctionTemplate>(isolate, tpl));
-}
-
-FridaEndpointParameters* EndpointParameters::TryParse(Local<Value> value,
-    Runtime* runtime) {
-  if (!value->IsObject())
-    return NULL;
-
-  auto impl = Nan::Get(value.As<Object>(), Nan::New("impl").ToLocalChecked())
-      .ToLocalChecked();
-  if (!HasInstance(impl, runtime))
-    return NULL;
-
-  return ObjectWrap::Unwrap<EndpointParameters>(
-      impl.As<Object>())->GetHandle<FridaEndpointParameters>();
-}
-
-bool EndpointParameters::HasInstance(Local<Value> value, Runtime* runtime) {
-  auto tpl = Nan::New<FunctionTemplate>(
-      *static_cast<Persistent<FunctionTemplate>*>(
-      runtime->GetDataPointer(ENDPOINT_PARAMETERS_DATA_TEMPLATE)));
-  return tpl->HasInstance(value);
-}
-
-NAN_METHOD(EndpointParameters::New) {
-  if (!info.IsConstructCall()) {
-    Nan::ThrowError("Use the `new` keyword to create a new instance");
-    return;
-  }
-
-  if (info.Length() < 7) {
-    Nan::ThrowTypeError("Missing one or more arguments");
-    return;
-  }
-
-  auto runtime = GetRuntimeFromConstructorArgs(info);
-
-  auto address_value = info[0];
-  auto port_value = info[1];
-  auto certificate_value = info[2];
-  auto origin_value = info[3];
-  auto auth_token_value = info[4];
-  auto auth_callback_value = info[5];
-  auto asset_root_value = info[6];
-
-  gchar* address = NULL;
-  guint16 port = 0;
-  GTlsCertificate* certificate = NULL;
-  gchar* origin = NULL;
-  FridaAuthenticationService* auth_service = NULL;
-  GFile* asset_root = NULL;
-  bool valid = true;
-
-  if (!address_value->IsNull()) {
-    if (address_value->IsString()) {
-      Nan::Utf8String str(address_value);
-      address = g_strdup(*str);
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'address' must be a string");
-      valid = false;
-    }
-  }
-
-  if (valid && !port_value->IsNull()) {
-    auto val = Nan::To<int32_t>(port_value).FromMaybe(-1);
-    if (val >= 0 && val <= 65535) {
-      port = val;
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'port' must be a valid port number");
-      valid = false;
-    }
-  }
-
-  if (valid && !certificate_value->IsNull()) {
-    valid = Runtime::ValueToCertificate(certificate_value, &certificate);
-  }
-
-  if (valid && !origin_value->IsNull()) {
-    if (origin_value->IsString()) {
-      Nan::Utf8String str(origin_value);
-      origin = g_strdup(*str);
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'origin' must be a string");
-      valid = false;
-    }
-  }
-
-  if (valid && !auth_token_value->IsNull()) {
-    if (auth_token_value->IsString()) {
-      Nan::Utf8String auth_token(auth_token_value);
-      auth_service = FRIDA_AUTHENTICATION_SERVICE(
-          frida_static_authentication_service_new(*auth_token));
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'authToken' must be a string");
-      valid = false;
-    }
-  } else if (valid && !auth_callback_value->IsNull()) {
-    if (auth_callback_value->IsFunction()) {
-      auto auth_callback = Local<Function>::Cast(auth_callback_value);
-      auth_service =
-          frida_node_authentication_service_new(auth_callback, runtime);
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'authCallback' must be a function");
-      valid = false;
-    }
-  }
-
-  if (valid && !asset_root_value->IsNull()) {
-    if (asset_root_value->IsString()) {
-      Nan::Utf8String str(asset_root_value);
-      asset_root = g_file_new_for_path(*str);
-    } else {
-      Nan::ThrowTypeError("Bad argument, 'assetRoot' must be a string");
-      valid = false;
-    }
-  }
-
-  if (valid) {
-    auto handle = frida_endpoint_parameters_new(address, port, certificate,
-        origin, auth_service, asset_root);
-    auto wrapper = new EndpointParameters(handle, runtime);
-    g_object_unref(handle);
-    auto obj = info.This();
-    wrapper->Wrap(obj);
-
-    info.GetReturnValue().Set(obj);
-  }
-
-  g_clear_object(&asset_root);
-  g_clear_object(&auth_service);
-  g_free(origin);
-  g_clear_object(&certificate);
-  g_free(address);
-}
-
-}

package/src/endpoint_parameters.h

@@ -1,28 +0,0 @@
-#ifndef FRIDANODE_ENDPOINT_PARAMETERS_H
-#define FRIDANODE_ENDPOINT_PARAMETERS_H
-
-#include "glib_object.h"
-
-#include <frida-core.h>
-
-namespace frida {
-
-class EndpointParameters : public GLibObject {
- public:
-  static void Init(v8::Local<v8::Object> exports, Runtime* runtime);
-
-  static FridaEndpointParameters* TryParse(v8::Local<v8::Value> value,
-      Runtime* runtime);
-  static bool HasInstance(v8::Local<v8::Value> value, Runtime* runtime);
-
- private:
-  explicit EndpointParameters(FridaEndpointParameters* handle,
-      Runtime* runtime);
-  ~EndpointParameters();
-
-  static NAN_METHOD(New);
-};
-
-}
-
-#endif

package/src/glib_context.cc

@@ -1,62 +0,0 @@
-#include "glib_context.h"
-
-#define GLIB_CONTEXT_LOCK()   g_mutex_lock(&mutex_)
-#define GLIB_CONTEXT_UNLOCK() g_mutex_unlock(&mutex_)
-#define GLIB_CONTEXT_WAIT()   g_cond_wait(&cond_, &mutex_)
-#define GLIB_CONTEXT_SIGNAL() g_cond_signal(&cond_)
-
-namespace frida {
-
-GLibContext::GLibContext(GMainContext* main_context) : main_context_(main_context) {
-  g_mutex_init(&mutex_);
-  g_cond_init(&cond_);
-}
-
-GLibContext::~GLibContext() {
-  g_cond_clear(&cond_);
-  g_mutex_clear(&mutex_);
-}
-
-void GLibContext::Schedule(std::function<void ()> f) {
-  auto source = g_idle_source_new();
-  g_source_set_callback(source, InvokeCallback, new std::function<void ()>(f),
-      DestroyCallback);
-  g_source_attach(source, main_context_);
-  g_source_unref(source);
-}
-
-void GLibContext::Perform(std::function<void ()> f) {
-  volatile bool finished = false;
-
-  auto work = new std::function<void ()>([this, f, &finished]() {
-    f();
-
-    GLIB_CONTEXT_LOCK();
-    finished = true;
-    GLIB_CONTEXT_SIGNAL();
-    GLIB_CONTEXT_UNLOCK();
-  });
-
-  auto source = g_idle_source_new();
-  g_source_set_callback(source, InvokeCallback, work, DestroyCallback);
-  g_source_attach(source, main_context_);
-  g_source_unref(source);
-
-  GLIB_CONTEXT_LOCK();
-  while (!finished)
-    GLIB_CONTEXT_WAIT();
-  GLIB_CONTEXT_UNLOCK();
-}
-
-gboolean GLibContext::InvokeCallback(gpointer data) {
-  auto f = static_cast<std::function<void ()>*>(data);
-  (*f)();
-  return FALSE;
-}
-
-void GLibContext::DestroyCallback(gpointer data) {
-  auto f = static_cast<std::function<void ()>*>(data);
-  delete f;
-}
-
-}