/*
*
* 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 <ruby/ruby.h>
#include <string.h>
#include "rb_channel_credentials.h"
#include "rb_grpc_imports.generated.h"
#include <grpc/grpc.h>
#include <grpc/grpc_security.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include "rb_call_credentials.h"
#include "rb_grpc.h"
/* grpc_rb_cChannelCredentials is the ruby class that proxies
grpc_channel_credentials. */
static VALUE grpc_rb_cChannelCredentials = Qnil;
static char* pem_root_certs = NULL;
/* grpc_rb_channel_credentials wraps a grpc_channel_credentials. It provides a
* mark object that is used to hold references to any objects used to create
* the credentials. */
typedef struct grpc_rb_channel_credentials {
/* Holder of ruby objects involved in constructing the credentials */
VALUE mark;
/* The actual credentials */
grpc_channel_credentials* wrapped;
} grpc_rb_channel_credentials;
/* Destroys the credentials instances. */
static void grpc_rb_channel_credentials_free(void* p) {
grpc_rb_channel_credentials* wrapper = NULL;
if (p == NULL) {
return;
};
wrapper = (grpc_rb_channel_credentials*)p;
grpc_channel_credentials_release(wrapper->wrapped);
wrapper->wrapped = NULL;
xfree(p);
}
/* Protects the mark object from GC */
static void grpc_rb_channel_credentials_mark(void* p) {
grpc_rb_channel_credentials* wrapper = NULL;
if (p == NULL) {
return;
}
wrapper = (grpc_rb_channel_credentials*)p;
if (wrapper->mark != Qnil) {
rb_gc_mark(wrapper->mark);
}
}
static rb_data_type_t grpc_rb_channel_credentials_data_type = {
"grpc_channel_credentials",
{grpc_rb_channel_credentials_mark,
grpc_rb_channel_credentials_free,
GRPC_RB_MEMSIZE_UNAVAILABLE,
{NULL, NULL}},
NULL,
NULL,
#ifdef RUBY_TYPED_FREE_IMMEDIATELY
RUBY_TYPED_FREE_IMMEDIATELY
#endif
};
/* Allocates ChannelCredential instances.
Provides safe initial defaults for the instance fields. */
static VALUE grpc_rb_channel_credentials_alloc(VALUE cls) {
grpc_rb_channel_credentials* wrapper = ALLOC(grpc_rb_channel_credentials);
wrapper->wrapped = NULL;
wrapper->mark = Qnil;
return TypedData_Wrap_Struct(cls, &grpc_rb_channel_credentials_data_type,
wrapper);
}
/* Creates a wrapping object for a given channel credentials. This should only
* be called with grpc_channel_credentials objects that are not already
* associated with any Ruby object. */
VALUE grpc_rb_wrap_channel_credentials(grpc_channel_credentials* c,
VALUE mark) {
VALUE rb_wrapper;
grpc_rb_channel_credentials* wrapper;
if (c == NULL) {
return Qnil;
}
rb_wrapper = grpc_rb_channel_credentials_alloc(grpc_rb_cChannelCredentials);
TypedData_Get_Struct(rb_wrapper, grpc_rb_channel_credentials,
&grpc_rb_channel_credentials_data_type, wrapper);
wrapper->wrapped = c;
wrapper->mark = mark;
return rb_wrapper;
}
/* The attribute used on the mark object to hold the pem_root_certs. */
static ID id_pem_root_certs;
/* The attribute used on the mark object to hold the pem_private_key. */
static ID id_pem_private_key;
/* The attribute used on the mark object to hold the pem_private_key. */
static ID id_pem_cert_chain;
/*
call-seq:
creds1 = Credentials.new()
...
creds2 = Credentials.new(pem_root_certs)
...
creds3 = Credentials.new(pem_root_certs, pem_private_key,
pem_cert_chain)
pem_root_certs: (optional) PEM encoding of the server root certificate
pem_private_key: (optional) PEM encoding of the client's private key
pem_cert_chain: (optional) PEM encoding of the client's cert chain
Initializes Credential instances. */
static VALUE grpc_rb_channel_credentials_init(int argc, VALUE* argv,
VALUE self) {
VALUE pem_root_certs = Qnil;
VALUE pem_private_key = Qnil;
VALUE pem_cert_chain = Qnil;
grpc_rb_channel_credentials* wrapper = NULL;
grpc_channel_credentials* creds = NULL;
grpc_ssl_pem_key_cert_pair key_cert_pair;
const char* pem_root_certs_cstr = NULL;
MEMZERO(&key_cert_pair, grpc_ssl_pem_key_cert_pair, 1);
grpc_ruby_once_init();
/* "03" == no mandatory arg, 3 optional */
rb_scan_args(argc, argv, "03", &pem_root_certs, &pem_private_key,
&pem_cert_chain);
TypedData_Get_Struct(self, grpc_rb_channel_credentials,
&grpc_rb_channel_credentials_data_type, wrapper);
if (pem_root_certs != Qnil) {
pem_root_certs_cstr = RSTRING_PTR(pem_root_certs);
}
if (pem_private_key == Qnil && pem_cert_chain == Qnil) {
creds = grpc_ssl_credentials_create(pem_root_certs_cstr, NULL, NULL, NULL);
} else {
key_cert_pair.private_key = RSTRING_PTR(pem_private_key);
key_cert_pair.cert_chain = RSTRING_PTR(pem_cert_chain);
creds = grpc_ssl_credentials_create(pem_root_certs_cstr, &key_cert_pair,
NULL, NULL);
}
if (creds == NULL) {
rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");
return Qnil;
}
wrapper->wrapped = creds;
/* Add the input objects as hidden fields to preserve them. */
rb_ivar_set(self, id_pem_cert_chain, pem_cert_chain);
rb_ivar_set(self, id_pem_private_key, pem_private_key);
rb_ivar_set(self, id_pem_root_certs, pem_root_certs);
return self;
}
static VALUE grpc_rb_channel_credentials_compose(int argc, VALUE* argv,
VALUE self) {
grpc_channel_credentials* creds;
grpc_call_credentials* other;
grpc_channel_credentials* prev = NULL;
VALUE mark;
if (argc == 0) {
return self;
}
mark = rb_ary_new();
rb_ary_push(mark, self);
creds = grpc_rb_get_wrapped_channel_credentials(self);
for (int i = 0; i < argc; i++) {
rb_ary_push(mark, argv[i]);
other = grpc_rb_get_wrapped_call_credentials(argv[i]);
creds = grpc_composite_channel_credentials_create(creds, other, NULL);
if (prev != NULL) {
grpc_channel_credentials_release(prev);
}
prev = creds;
if (creds == NULL) {
rb_raise(rb_eRuntimeError,
"Failed to compose channel and call credentials");
}
}
return grpc_rb_wrap_channel_credentials(creds, mark);
}
static grpc_ssl_roots_override_result get_ssl_roots_override(
char** pem_root_certs_ptr) {
*pem_root_certs_ptr = pem_root_certs;
if (pem_root_certs == NULL) {
return GRPC_SSL_ROOTS_OVERRIDE_FAIL;
} else {
return GRPC_SSL_ROOTS_OVERRIDE_OK;
}
}
static VALUE grpc_rb_set_default_roots_pem(VALUE self, VALUE roots) {
char* roots_ptr = StringValueCStr(roots);
size_t length = strlen(roots_ptr);
(void)self;
pem_root_certs = gpr_malloc((length + 1) * sizeof(char));
memcpy(pem_root_certs, roots_ptr, length + 1);
return Qnil;
}
void Init_grpc_channel_credentials() {
grpc_rb_cChannelCredentials = rb_define_class_under(
grpc_rb_mGrpcCore, "ChannelCredentials", rb_cObject);
/* Allocates an object managed by the ruby runtime */
rb_define_alloc_func(grpc_rb_cChannelCredentials,
grpc_rb_channel_credentials_alloc);
/* Provides a ruby constructor and support for dup/clone. */
rb_define_method(grpc_rb_cChannelCredentials, "initialize",
grpc_rb_channel_credentials_init, -1);
rb_define_method(grpc_rb_cChannelCredentials, "initialize_copy",
grpc_rb_cannot_init_copy, 1);
rb_define_method(grpc_rb_cChannelCredentials, "compose",
grpc_rb_channel_credentials_compose, -1);
rb_define_module_function(grpc_rb_cChannelCredentials,
"set_default_roots_pem",
grpc_rb_set_default_roots_pem, 1);
grpc_set_ssl_roots_override_callback(get_ssl_roots_override);
id_pem_cert_chain = rb_intern("__pem_cert_chain");
id_pem_private_key = rb_intern("__pem_private_key");
id_pem_root_certs = rb_intern("__pem_root_certs");
}
/* Gets the wrapped grpc_channel_credentials from the ruby wrapper */
grpc_channel_credentials* grpc_rb_get_wrapped_channel_credentials(VALUE v) {
grpc_rb_channel_credentials* wrapper = NULL;
TypedData_Get_Struct(v, grpc_rb_channel_credentials,
&grpc_rb_channel_credentials_data_type, wrapper);
return wrapper->wrapped;
}