bool CQueryParameter::TransformParameter( Isolate* isolate, Local< Value > value, sBindParameter** pOutParam )
{
HandleScope scope( isolate );
Local< Context > context = isolate->GetCurrentContext( );
sBindParameter* pParameter = *pOutParam;
if( value->IsNull( ) )
{
pParameter->SetNull( );
}
else if( value->IsString( ) )
{
pParameter->SetString( value.As<String>( ) );
}
else if( value->IsBoolean( ) )
{
pParameter->SetBool( value->BooleanValue( context ).FromJust( ) );
}
else if( value->IsInt32( ) )
{
pParameter->SetInt( value->Int32Value( context ).FromJust( ) );
}
else if( value->IsUint32( ) )
{
pParameter->SetUInt( value->Uint32Value( context ).FromJust( ) );
}
else if( value->IsNumber( ) )
{
double d = value->NumberValue( context ).FromJust( );
if( _isnan( d ) || !_finite( d ) )
{
return false;
}
else if( d == floor( d ) &&
d >= std::numeric_limits<int64_t>::min( ) &&
d <= std::numeric_limits<int64_t>::max( )
)
{
pParameter->SetInt64( value->IntegerValue( context ).FromJust( ) );
}
else
{
pParameter->SetDouble( value->NumberValue( context ).FromJust( ) );
}
}
else if( value->IsDate( ) )
{
Local<Date> dateObject = value.As<Date>( );
pParameter->SetDate( dateObject->NumberValue( context ).FromJust( ) );
}
else if( value->IsObject( ) )
{
Local<Object> objValue = value.As<Object>( );
if( node::Buffer::HasInstance( value ) )
{
pParameter->SetBuffer( isolate, objValue );
}
else
{
Local< String > strId = String::NewFromUtf8( isolate, "_objId", NewStringType::kNormal ).ToLocalChecked( );
if( objValue->HasRealNamedProperty( context, strId ).FromJust( ) )
{
Local< Uint32 > numTypeId = objValue->Get( context, strId ).ToLocalChecked( ).As< Uint32 >( );
uint32_t nType = numTypeId->Int32Value( context ).FromJust( );
switch( nType )
{
case ID_INPUT_STREAM:
{
Local<Value> type = objValue->Get(
context, String::NewFromUtf8( isolate, "type", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> stream = objValue->Get(
context, String::NewFromUtf8( isolate, "stream", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> length = objValue->Get(
context, String::NewFromUtf8( isolate, "length", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
pParameter->SetStream( isolate, type->Uint32Value( context ).FromJust( ), stream, static_cast< SQLUINTEGER >( length->IntegerValue( context ).FromJust( ) ) );
break;
}
case ID_NUMERIC_VALUE:
{
Local< Value > precision = objValue->Get(
context, String::NewFromUtf8( isolate, "precision", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> scale = objValue->Get(
context, String::NewFromUtf8( isolate, "scale", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> sign = objValue->Get(
context, String::NewFromUtf8( isolate, "sign", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local<Value> value = objValue->Get(
context, String::NewFromUtf8( isolate, "value", NewStringType::kNormal ).ToLocalChecked( )
).ToLocalChecked( );
Local< Uint32 > numPrecision = precision.As<Uint32>( );
Local< Uint32 > numScale = scale.As<Uint32>( );
Local< Boolean > boolSign = sign.As<Boolean>( );
Local< ArrayBuffer > arrBuffer = ( value.As<Uint8Array>( ) )->Buffer( );
ArrayBuffer::Contents contents = arrBuffer->GetContents( );
if( contents.ByteLength( ) > SQL_MAX_NUMERIC_LEN )
{
return false;
}
pParameter->SetNumeric( numPrecision->Uint32Value( context ).FromJust( ),
numScale->Uint32Value( context ).FromJust( ),
boolSign->BooleanValue( context ).FromJust( ),
contents.Data( ),
contents.ByteLength( )
);
break;
}
default:
{
return false;
}
}
}
else
{
return false;
}
}
}
else
{
return false;
}
return true;
}
Handle<Value>
NodeSandbox::node_spawn(const Arguments& args)
{
HandleScope scope;
char** argv;
std::map<std::string, std::string> envp;
SandboxWrapper* wrap;
wrap = node::ObjectWrap::Unwrap<SandboxWrapper>(args.This());
argv = static_cast<char**>(calloc (sizeof (char*), args.Length()+1));
argv[args.Length()] = nullptr;
for(int i = 0; i < args.Length(); i++) {
if (args[i]->IsString()) {
Local<String> v = args[i]->ToString();
argv[i] = static_cast<char*>(calloc(sizeof(char), v->Utf8Length()+1));
v->WriteUtf8(argv[i]);
} else {
if (i <= args.Length() - 2 ) {
ThrowException(Exception::TypeError(String::New("Arguments must be strings.")));
goto out;
} else {
// Last parameter is an options structure
Local<Object> options = args[i]->ToObject();
if (!options.IsEmpty()) {
if (options->HasRealNamedProperty(String::NewSymbol("env"))) {
Local<Object> envOptions = options->Get(String::NewSymbol("env"))->ToObject();
if (!envOptions.IsEmpty()) {
Local<Array> envArray = envOptions->GetOwnPropertyNames();
for (uint32_t i = 0; i < envArray->Length(); i++) {
std::vector<char> strName;
std::vector<char> strValue;
Local<String> envName;
Local<String> envValue;
if (!(envArray->Get(i)->IsString() && envArray->Get(i)->IsString()))
goto err_env;
envName = envArray->Get(i)->ToString();
envValue = envOptions->Get(envName)->ToString();
strName.resize (envName->Utf8Length()+1);
strValue.resize (envValue->Utf8Length()+1);
envName->WriteUtf8 (strName.data());
envValue->WriteUtf8 (strValue.data());
envp.insert (std::make_pair(std::string (strName.data()), std::string(strValue.data())));
}
} else {
goto err_env;
}
}
} else {
goto err_options;
}
}
}
}
wrap->sbox->getVFS().setCWD ("/contract/");
wrap->sbox->spawn(argv, envp);
goto out;
err_env:
ThrowException(Exception::TypeError(String::New("'env' option must be a map of string:string")));
goto out;
err_options:
ThrowException(Exception::TypeError(String::New("Last argument must be an options structure.")));
goto out;
out:
for (int i = 0; i < args.Length();i ++) {
free (argv[i]);
}
free (argv);
return Undefined();
}
void Proxy::proxyConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
{
LOGD(TAG, "proxy constructor callback!");
Isolate* isolate = args.GetIsolate();
EscapableHandleScope scope(isolate);
JNIEnv *env = JNIScope::getEnv();
Local<Object> jsProxy = args.This();
// First things first, we need to wrap the object in case future calls need to unwrap proxy!
Proxy* proxy = new Proxy(NULL);
proxy->wrap(isolate, jsProxy);
// every instance gets a special "_properties" object for us to use internally for get/setProperty
jsProxy->DefineOwnProperty(isolate->GetCurrentContext(), propertiesSymbol.Get(isolate), Object::New(isolate), static_cast<PropertyAttribute>(DontEnum));
// Now we hook up a java Object from the JVM...
jobject javaProxy = ProxyFactory::unwrapJavaProxy(args); // do we already have one that got passed in?
bool deleteRef = false;
if (!javaProxy) {
// No passed in java object, so let's create an instance
// Look up java class from prototype...
Local<Object> prototype = jsProxy->GetPrototype()->ToObject(isolate);
Local<Function> constructor = prototype->Get(constructorSymbol.Get(isolate)).As<Function>();
Local<External> wrap = constructor->Get(javaClassSymbol.Get(isolate)).As<External>();
jclass javaClass = static_cast<jclass>(wrap->Value());
// Now we create an instance of the class and hook it up
JNIUtil::logClassName("Creating java proxy for class %s", javaClass);
javaProxy = ProxyFactory::createJavaProxy(javaClass, jsProxy, args);
deleteRef = true;
}
proxy->attach(javaProxy);
int length = args.Length();
if (length > 0 && args[0]->IsObject()) {
bool extend = true;
Local<Object> createProperties = args[0].As<Object>();
Local<String> constructorName = createProperties->GetConstructorName();
if (strcmp(*titanium::Utf8Value(constructorName), "Arguments") == 0) {
extend = false;
int32_t argsLength = createProperties->Get(STRING_NEW(isolate, "length"))->Int32Value();
if (argsLength > 1) {
Local<Value> properties = createProperties->Get(1);
if (properties->IsObject()) {
extend = true;
createProperties = properties.As<Object>();
}
}
}
if (extend) {
Local<Array> names = createProperties->GetOwnPropertyNames();
int length = names->Length();
Local<Object> properties = jsProxy->Get(propertiesSymbol.Get(isolate))->ToObject(isolate);
for (int i = 0; i < length; ++i) {
Local<Value> name = names->Get(i);
Local<Value> value = createProperties->Get(name);
bool isProperty = true;
if (name->IsString()) {
Local<String> nameString = name.As<String>();
if (!jsProxy->HasRealNamedCallbackProperty(nameString)
&& !jsProxy->HasRealNamedProperty(nameString)) {
jsProxy->Set(name, value);
isProperty = false;
}
}
if (isProperty) {
properties->Set(name, value);
}
}
}
}
if (!args.Data().IsEmpty() && args.Data()->IsFunction()) {
Local<Function> proxyFn = args.Data().As<Function>();
Local<Value> *fnArgs = new Local<Value>[length];
for (int i = 0; i < length; ++i) {
fnArgs[i] = args[i];
}
proxyFn->Call(isolate->GetCurrentContext(), jsProxy, length, fnArgs);
}
if (deleteRef) {
JNIEnv *env = JNIScope::getEnv();
if (env) {
env->DeleteLocalRef(javaProxy);
}
}
args.GetReturnValue().Set(scope.Escape(jsProxy));
}
Handle<Value> Proxy::proxyConstructor(const Arguments& args)
{
HandleScope scope;
JNIEnv *env = JNIScope::getEnv();
Local<Object> jsProxy = args.Holder();
Handle<Object> properties = Object::New();
jsProxy->Set(propertiesSymbol, properties, PropertyAttribute(DontEnum));
Handle<Object> prototype = jsProxy->GetPrototype()->ToObject();
Handle<Function> constructor = Handle<Function>::Cast(prototype->Get(constructorSymbol));
jclass javaClass = (jclass) External::Unwrap(constructor->Get(javaClassSymbol));
// If ProxyFactory::createV8Proxy invoked us, unwrap
// the pre-created Java proxy it sent.
jobject javaProxy = ProxyFactory::unwrapJavaProxy(args);
bool deleteRef = false;
if (!javaProxy) {
javaProxy = ProxyFactory::createJavaProxy(javaClass, jsProxy, args);
deleteRef = true;
}
JNIUtil::logClassName("Create proxy: %s", javaClass);
Proxy *proxy = new Proxy(javaProxy);
proxy->Wrap(jsProxy);
int length = args.Length();
if (length > 0 && args[0]->IsObject()) {
/*
Handle<Value> argsStr = V8Util::jsonStringify(args[0]);
String::Utf8Value str(argsStr);
LOGV(TAG, " with args: %s", *str);
*/
bool extend = true;
Handle<Object> createProperties = args[0]->ToObject();
Local<String> constructorName = createProperties->GetConstructorName();
if (strcmp(*String::Utf8Value(constructorName), "Arguments") == 0) {
extend = false;
int32_t argsLength = createProperties->Get(String::New("length"))->Int32Value();
if (argsLength > 1) {
Handle<Value> properties = createProperties->Get(1);
if (properties->IsObject()) {
extend = true;
createProperties = properties->ToObject();
}
}
}
if (extend) {
Handle<Array> names = createProperties->GetOwnPropertyNames();
int length = names->Length();
for (int i = 0; i < length; ++i) {
Handle<Value> name = names->Get(i);
Handle<Value> value = createProperties->Get(name);
bool isProperty = true;
if (name->IsString()) {
Handle<String> nameString = name->ToString();
if (!jsProxy->HasRealNamedCallbackProperty(nameString)
&& !jsProxy->HasRealNamedProperty(nameString)) {
jsProxy->Set(name, value);
isProperty = false;
}
}
if (isProperty) {
properties->Set(name, value);
}
}
}
}
if (!args.Data().IsEmpty() && args.Data()->IsFunction()) {
Handle<Function> proxyFn = Handle<Function>::Cast(args.Data());
Handle<Value> *fnArgs = new Handle<Value>[length];
for (int i = 0; i < length; ++i) {
fnArgs[i] = args[i];
}
proxyFn->Call(jsProxy, length, fnArgs);
}
if (deleteRef) {
JNIEnv *env = JNIScope::getEnv();
if (env) {
env->DeleteLocalRef(javaProxy);
}
}
return jsProxy;
}