mirror of
https://github.com/musix-org/musix-oss
synced 2024-11-14 03:30:18 +00:00
254 lines
8.2 KiB
C++
254 lines
8.2 KiB
C++
/*
|
|
*
|
|
* Copyright 2015 gRPC authors.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*/
|
|
|
|
#include <node.h>
|
|
|
|
#include "call.h"
|
|
#include "call_credentials.h"
|
|
#include "channel_credentials.h"
|
|
#include "util.h"
|
|
#include "grpc/grpc.h"
|
|
#include "grpc/grpc_security.h"
|
|
#include "grpc/support/log.h"
|
|
|
|
namespace grpc {
|
|
namespace node {
|
|
|
|
using Nan::Callback;
|
|
using Nan::EscapableHandleScope;
|
|
using Nan::HandleScope;
|
|
using Nan::Maybe;
|
|
using Nan::MaybeLocal;
|
|
using Nan::ObjectWrap;
|
|
using Nan::Persistent;
|
|
using Nan::Utf8String;
|
|
|
|
using v8::Array;
|
|
using v8::Context;
|
|
using v8::Exception;
|
|
using v8::External;
|
|
using v8::Function;
|
|
using v8::FunctionTemplate;
|
|
using v8::Integer;
|
|
using v8::Local;
|
|
using v8::Object;
|
|
using v8::ObjectTemplate;
|
|
using v8::Value;
|
|
|
|
Nan::Callback *ChannelCredentials::constructor;
|
|
Persistent<FunctionTemplate> ChannelCredentials::fun_tpl;
|
|
|
|
ChannelCredentials::ChannelCredentials(grpc_channel_credentials *credentials)
|
|
: wrapped_credentials(credentials) {}
|
|
|
|
ChannelCredentials::~ChannelCredentials() {
|
|
grpc_channel_credentials_release(wrapped_credentials);
|
|
}
|
|
|
|
static int verify_peer_callback_wrapper(const char* servername, const char* cert, void* userdata) {
|
|
Nan::HandleScope scope;
|
|
Nan::TryCatch try_catch;
|
|
Nan::Callback *callback = (Nan::Callback*)userdata;
|
|
|
|
const unsigned argc = 2;
|
|
Local<Value> argv[argc];
|
|
if (servername == NULL) {
|
|
argv[0] = Nan::Null();
|
|
} else {
|
|
argv[0] = Nan::New<v8::String>(servername).ToLocalChecked();
|
|
}
|
|
if (cert == NULL) {
|
|
argv[1] = Nan::Null();
|
|
} else {
|
|
argv[1] = Nan::New<v8::String>(cert).ToLocalChecked();
|
|
}
|
|
|
|
MaybeLocal<Value> result = Nan::Call(*callback, argc, argv);
|
|
|
|
// Catch any exception and return with a distinct status code which indicates this
|
|
if (try_catch.HasCaught()) {
|
|
return 2;
|
|
}
|
|
|
|
// If the result is an error, return a failure
|
|
if (result.ToLocalChecked()->IsNativeError()) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void verify_peer_callback_destruct(void *userdata) {
|
|
Nan::Callback *callback = (Nan::Callback*)userdata;
|
|
delete callback;
|
|
}
|
|
|
|
void ChannelCredentials::Init(Local<Object> exports) {
|
|
HandleScope scope;
|
|
Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
|
|
tpl->SetClassName(Nan::New("ChannelCredentials").ToLocalChecked());
|
|
tpl->InstanceTemplate()->SetInternalFieldCount(1);
|
|
Nan::SetPrototypeMethod(tpl, "compose", Compose);
|
|
fun_tpl.Reset(tpl);
|
|
Local<Function> ctr = Nan::GetFunction(tpl).ToLocalChecked();
|
|
Nan::Set(
|
|
ctr, Nan::New("createSsl").ToLocalChecked(),
|
|
Nan::GetFunction(Nan::New<FunctionTemplate>(CreateSsl)).ToLocalChecked());
|
|
Nan::Set(ctr, Nan::New("createInsecure").ToLocalChecked(),
|
|
Nan::GetFunction(Nan::New<FunctionTemplate>(CreateInsecure))
|
|
.ToLocalChecked());
|
|
Nan::Set(exports, Nan::New("ChannelCredentials").ToLocalChecked(), ctr);
|
|
constructor = new Nan::Callback(ctr);
|
|
}
|
|
|
|
bool ChannelCredentials::HasInstance(Local<Value> val) {
|
|
HandleScope scope;
|
|
return Nan::New(fun_tpl)->HasInstance(val);
|
|
}
|
|
|
|
Local<Value> ChannelCredentials::WrapStruct(
|
|
grpc_channel_credentials *credentials) {
|
|
EscapableHandleScope scope;
|
|
const int argc = 1;
|
|
Local<Value> argv[argc] = {
|
|
Nan::New<External>(reinterpret_cast<void *>(credentials))};
|
|
MaybeLocal<Object> maybe_instance =
|
|
Nan::NewInstance(constructor->GetFunction(), argc, argv);
|
|
if (maybe_instance.IsEmpty()) {
|
|
return scope.Escape(Nan::Null());
|
|
} else {
|
|
return scope.Escape(maybe_instance.ToLocalChecked());
|
|
}
|
|
}
|
|
|
|
grpc_channel_credentials *ChannelCredentials::GetWrappedCredentials() {
|
|
return wrapped_credentials;
|
|
}
|
|
|
|
NAN_METHOD(ChannelCredentials::New) {
|
|
if (info.IsConstructCall()) {
|
|
if (!info[0]->IsExternal()) {
|
|
return Nan::ThrowTypeError(
|
|
"ChannelCredentials can only be created with the provided functions");
|
|
}
|
|
Local<External> ext = info[0].As<External>();
|
|
grpc_channel_credentials *creds_value =
|
|
reinterpret_cast<grpc_channel_credentials *>(ext->Value());
|
|
ChannelCredentials *credentials = new ChannelCredentials(creds_value);
|
|
credentials->Wrap(info.This());
|
|
info.GetReturnValue().Set(info.This());
|
|
return;
|
|
} else {
|
|
// This should never be called directly
|
|
return Nan::ThrowTypeError(
|
|
"ChannelCredentials can only be created with the provided functions");
|
|
}
|
|
}
|
|
|
|
NAN_METHOD(ChannelCredentials::CreateSsl) {
|
|
StringOrNull root_certs;
|
|
StringOrNull private_key;
|
|
StringOrNull cert_chain;
|
|
if (::node::Buffer::HasInstance(info[0])) {
|
|
root_certs.assign(info[0]);
|
|
} else if (!(info[0]->IsNull() || info[0]->IsUndefined())) {
|
|
return Nan::ThrowTypeError("createSsl's first argument must be a Buffer");
|
|
}
|
|
if (::node::Buffer::HasInstance(info[1])) {
|
|
private_key.assign(info[1]);
|
|
} else if (!(info[1]->IsNull() || info[1]->IsUndefined())) {
|
|
return Nan::ThrowTypeError(
|
|
"createSSl's second argument must be a Buffer if provided");
|
|
}
|
|
if (::node::Buffer::HasInstance(info[2])) {
|
|
cert_chain.assign(info[2]);
|
|
} else if (!(info[2]->IsNull() || info[2]->IsUndefined())) {
|
|
return Nan::ThrowTypeError(
|
|
"createSSl's third argument must be a Buffer if provided");
|
|
}
|
|
grpc_ssl_pem_key_cert_pair key_cert_pair = {private_key.get(),
|
|
cert_chain.get()};
|
|
if (private_key.isAssigned() != cert_chain.isAssigned()) {
|
|
return Nan::ThrowError(
|
|
"createSsl's second and third arguments must be"
|
|
" provided or omitted together");
|
|
}
|
|
|
|
verify_peer_options verify_options = {NULL, NULL, NULL};
|
|
if (!info[3]->IsUndefined()) {
|
|
if (!info[3]->IsObject()) {
|
|
return Nan::ThrowTypeError("createSsl's fourth argument must be an object");
|
|
}
|
|
Local<Object> object = Nan::To<Object>(info[3]).ToLocalChecked();
|
|
|
|
Local<Value> checkServerIdentityValue = Nan::Get(object,
|
|
Nan::New("checkServerIdentity").ToLocalChecked()).ToLocalChecked();
|
|
if (!checkServerIdentityValue->IsUndefined()) {
|
|
if (!checkServerIdentityValue->IsFunction()) {
|
|
return Nan::ThrowTypeError("Value of checkServerIdentity must be a function.");
|
|
}
|
|
Nan::Callback *callback = new Callback(Local<Function>::Cast(
|
|
checkServerIdentityValue));
|
|
verify_options.verify_peer_callback = verify_peer_callback_wrapper;
|
|
verify_options.verify_peer_callback_userdata = (void*)callback;
|
|
verify_options.verify_peer_destruct = verify_peer_callback_destruct;
|
|
}
|
|
}
|
|
|
|
grpc_channel_credentials *creds = grpc_ssl_credentials_create(
|
|
root_certs.get(), private_key.isAssigned() ? &key_cert_pair : NULL,
|
|
&verify_options, NULL);
|
|
if (creds == NULL) {
|
|
info.GetReturnValue().SetNull();
|
|
} else {
|
|
info.GetReturnValue().Set(WrapStruct(creds));
|
|
}
|
|
}
|
|
|
|
NAN_METHOD(ChannelCredentials::Compose) {
|
|
if (!ChannelCredentials::HasInstance(info.This())) {
|
|
return Nan::ThrowTypeError(
|
|
"compose can only be called on ChannelCredentials objects");
|
|
}
|
|
if (!CallCredentials::HasInstance(info[0])) {
|
|
return Nan::ThrowTypeError(
|
|
"compose's first argument must be a CallCredentials object");
|
|
}
|
|
ChannelCredentials *self =
|
|
ObjectWrap::Unwrap<ChannelCredentials>(info.This());
|
|
if (self->wrapped_credentials == NULL) {
|
|
return Nan::ThrowTypeError("Cannot compose insecure credential");
|
|
}
|
|
CallCredentials *other = ObjectWrap::Unwrap<CallCredentials>(
|
|
Nan::To<Object>(info[0]).ToLocalChecked());
|
|
grpc_channel_credentials *creds = grpc_composite_channel_credentials_create(
|
|
self->wrapped_credentials, other->GetWrappedCredentials(), NULL);
|
|
if (creds == NULL) {
|
|
info.GetReturnValue().SetNull();
|
|
} else {
|
|
info.GetReturnValue().Set(WrapStruct(creds));
|
|
}
|
|
}
|
|
|
|
NAN_METHOD(ChannelCredentials::CreateInsecure) {
|
|
info.GetReturnValue().Set(WrapStruct(NULL));
|
|
}
|
|
|
|
} // namespace node
|
|
} // namespace grpc
|