grpc 1.23.1 → 1.24.0.pre1

data/src/core/tsi/alts/handshaker/transport_security_common_api.cc

@@ -29,9 +29,6 @@ bool grpc_gcp_rpc_protocol_versions_set_max(
             "grpc_gcp_rpc_protocol_versions_set_max().");
     return false;
   }
-  versions->has_max_rpc_version = true;
-  versions->max_rpc_version.has_major = true;
-  versions->max_rpc_version.has_minor = true;
   versions->max_rpc_version.major = max_major;
   versions->max_rpc_version.minor = max_minor;
   return true;
@@ -46,63 +43,45 @@ bool grpc_gcp_rpc_protocol_versions_set_min(
             "grpc_gcp_rpc_protocol_versions_set_min().");
     return false;
   }
-  versions->has_min_rpc_version = true;
-  versions->min_rpc_version.has_major = true;
-  versions->min_rpc_version.has_minor = true;
   versions->min_rpc_version.major = min_major;
   versions->min_rpc_version.minor = min_minor;
   return true;
 }
 
-size_t grpc_gcp_rpc_protocol_versions_encode_length(
-    const grpc_gcp_rpc_protocol_versions* versions) {
-  if (versions == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to "
-            "grpc_gcp_rpc_protocol_versions_encode_length().");
-    return 0;
-  }
-  pb_ostream_t size_stream;
-  memset(&size_stream, 0, sizeof(pb_ostream_t));
-  if (!pb_encode(&size_stream, grpc_gcp_RpcProtocolVersions_fields, versions)) {
-    gpr_log(GPR_ERROR, "nanopb error: %s", PB_GET_ERROR(&size_stream));
-    return 0;
-  }
-  return size_stream.bytes_written;
-}
-
-bool grpc_gcp_rpc_protocol_versions_encode_to_raw_bytes(
-    const grpc_gcp_rpc_protocol_versions* versions, uint8_t* bytes,
-    size_t bytes_length) {
-  if (versions == nullptr || bytes == nullptr || bytes_length == 0) {
+bool grpc_gcp_rpc_protocol_versions_encode(
+    const grpc_gcp_rpc_protocol_versions* versions, grpc_slice* slice) {
+  if (versions == nullptr || slice == nullptr) {
     gpr_log(GPR_ERROR,
             "Invalid nullptr arguments to "
-            "grpc_gcp_rpc_protocol_versions_encode_to_raw_bytes().");
-    return false;
-  }
-  pb_ostream_t output_stream = pb_ostream_from_buffer(bytes, bytes_length);
-  if (!pb_encode(&output_stream, grpc_gcp_RpcProtocolVersions_fields,
-                 versions)) {
-    gpr_log(GPR_ERROR, "nanopb error: %s", PB_GET_ERROR(&output_stream));
+            "grpc_gcp_rpc_protocol_versions_encode().");
     return false;
   }
-  return true;
+  upb::Arena arena;
+  grpc_gcp_RpcProtocolVersions* versions_msg =
+      grpc_gcp_RpcProtocolVersions_new(arena.ptr());
+  grpc_gcp_RpcProtocolVersions_assign_from_struct(versions_msg, arena.ptr(),
+                                                  versions);
+  return grpc_gcp_rpc_protocol_versions_encode(versions_msg, arena.ptr(),
+                                               slice);
 }
 
 bool grpc_gcp_rpc_protocol_versions_encode(
-    const grpc_gcp_rpc_protocol_versions* versions, grpc_slice* slice) {
-  if (versions == nullptr || slice == nullptr) {
+    const grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    grpc_slice* slice) {
+  if (versions == nullptr || arena == nullptr || slice == nullptr) {
     gpr_log(GPR_ERROR,
             "Invalid nullptr arguments to "
             "grpc_gcp_rpc_protocol_versions_encode().");
     return false;
   }
-  size_t encoded_length =
-      grpc_gcp_rpc_protocol_versions_encode_length(versions);
-  if (encoded_length == 0) return false;
-  *slice = grpc_slice_malloc(encoded_length);
-  return grpc_gcp_rpc_protocol_versions_encode_to_raw_bytes(
-      versions, GRPC_SLICE_START_PTR(*slice), encoded_length);
+  size_t buf_length;
+  char* buf =
+      grpc_gcp_RpcProtocolVersions_serialize(versions, arena, &buf_length);
+  if (buf == nullptr) {
+    return false;
+  }
+  *slice = grpc_slice_from_copied_buffer(buf, buf_length);
+  return true;
 }
 
 bool grpc_gcp_rpc_protocol_versions_decode(
@@ -113,16 +92,63 @@ bool grpc_gcp_rpc_protocol_versions_decode(
             "grpc_gcp_rpc_protocol_versions_decode().");
     return false;
   }
-  pb_istream_t stream =
-      pb_istream_from_buffer(const_cast<uint8_t*>(GRPC_SLICE_START_PTR(slice)),
-                             GRPC_SLICE_LENGTH(slice));
-  if (!pb_decode(&stream, grpc_gcp_RpcProtocolVersions_fields, versions)) {
-    gpr_log(GPR_ERROR, "nanopb error: %s", PB_GET_ERROR(&stream));
+  upb::Arena arena;
+  grpc_gcp_RpcProtocolVersions* versions_msg =
+      grpc_gcp_RpcProtocolVersions_parse(
+          reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(slice)),
+          GRPC_SLICE_LENGTH(slice), arena.ptr());
+  if (versions_msg == nullptr) {
+    gpr_log(GPR_ERROR, "cannot deserialize RpcProtocolVersions message");
     return false;
   }
+  grpc_gcp_rpc_protocol_versions_assign_from_upb(versions, versions_msg);
   return true;
 }
 
+void grpc_gcp_rpc_protocol_versions_assign_from_upb(
+    grpc_gcp_rpc_protocol_versions* versions,
+    const grpc_gcp_RpcProtocolVersions* value) {
+  const grpc_gcp_RpcProtocolVersions_Version* max_version_msg =
+      grpc_gcp_RpcProtocolVersions_max_rpc_version(value);
+  if (max_version_msg != nullptr) {
+    versions->max_rpc_version.major =
+        grpc_gcp_RpcProtocolVersions_Version_major(max_version_msg);
+    versions->max_rpc_version.minor =
+        grpc_gcp_RpcProtocolVersions_Version_minor(max_version_msg);
+  } else {
+    versions->max_rpc_version.major = 0;
+    versions->max_rpc_version.minor = 0;
+  }
+  const grpc_gcp_RpcProtocolVersions_Version* min_version_msg =
+      grpc_gcp_RpcProtocolVersions_min_rpc_version(value);
+  if (min_version_msg != nullptr) {
+    versions->min_rpc_version.major =
+        grpc_gcp_RpcProtocolVersions_Version_major(min_version_msg);
+    versions->min_rpc_version.minor =
+        grpc_gcp_RpcProtocolVersions_Version_minor(min_version_msg);
+  } else {
+    versions->min_rpc_version.major = 0;
+    versions->min_rpc_version.minor = 0;
+  }
+}
+
+void grpc_gcp_RpcProtocolVersions_assign_from_struct(
+    grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    const grpc_gcp_rpc_protocol_versions* value) {
+  grpc_gcp_RpcProtocolVersions_Version* max_version_msg =
+      grpc_gcp_RpcProtocolVersions_mutable_max_rpc_version(versions, arena);
+  grpc_gcp_RpcProtocolVersions_Version_set_major(max_version_msg,
+                                                 value->max_rpc_version.major);
+  grpc_gcp_RpcProtocolVersions_Version_set_minor(max_version_msg,
+                                                 value->max_rpc_version.minor);
+  grpc_gcp_RpcProtocolVersions_Version* min_version_msg =
+      grpc_gcp_RpcProtocolVersions_mutable_min_rpc_version(versions, arena);
+  grpc_gcp_RpcProtocolVersions_Version_set_major(min_version_msg,
+                                                 value->min_rpc_version.major);
+  grpc_gcp_RpcProtocolVersions_Version_set_minor(min_version_msg,
+                                                 value->min_rpc_version.minor);
+}
+
 bool grpc_gcp_rpc_protocol_versions_copy(
     const grpc_gcp_rpc_protocol_versions* src,
     grpc_gcp_rpc_protocol_versions* dst) {

data/src/core/tsi/alts/handshaker/transport_security_common_api.h

@@ -21,20 +21,24 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "pb_decode.h"
-#include "pb_encode.h"
-
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/tsi/alts/handshaker/transport_security_common.pb.h"
+#include "src/proto/grpc/gcp/transport_security_common.upb.h"
 
-typedef grpc_gcp_RpcProtocolVersions grpc_gcp_rpc_protocol_versions;
+// C struct coresponding to protobuf message RpcProtocolVersions.Version
+typedef struct _grpc_gcp_RpcProtocolVersions_Version {
+  uint32_t major;
+  uint32_t minor;
+} grpc_gcp_rpc_protocol_versions_version;
 
-typedef grpc_gcp_RpcProtocolVersions_Version
-    grpc_gcp_rpc_protocol_versions_version;
+// C struct coresponding to protobuf message RpcProtocolVersions
+typedef struct _grpc_gcp_RpcProtocolVersions {
+  grpc_gcp_rpc_protocol_versions_version max_rpc_version;
+  grpc_gcp_rpc_protocol_versions_version min_rpc_version;
+} grpc_gcp_rpc_protocol_versions;
 
 /**
  * This method sets the value for max_rpc_versions field of rpc protocol
@@ -65,41 +69,30 @@ bool grpc_gcp_rpc_protocol_versions_set_min(
     uint32_t min_minor);
 
 /**
- * This method computes serialized byte length of rpc protocol versions.
- *
- * - versions: an rpc protocol versions instance.
- *
- * The method returns serialized byte length. It returns 0 on failure.
- */
-size_t grpc_gcp_rpc_protocol_versions_encode_length(
-    const grpc_gcp_rpc_protocol_versions* versions);
-
-/**
- * This method serializes rpc protocol versions and writes the result to
- * the memory buffer provided by the caller. Caller is responsible for
- * allocating sufficient memory to store the serialized data.
+ * This method serializes an rpc protocol version and returns serialized rpc
+ * versions in grpc slice.
  *
  * - versions: an rpc protocol versions instance.
- * - bytes: bytes buffer where the result will be written to.
- * - bytes_length: length of the bytes buffer.
+ * - slice: grpc slice where the serialized result will be written.
  *
  * The method returns true on success and false otherwise.
  */
-bool grpc_gcp_rpc_protocol_versions_encode_to_raw_bytes(
-    const grpc_gcp_rpc_protocol_versions* versions, uint8_t* bytes,
-    size_t bytes_length);
+bool grpc_gcp_rpc_protocol_versions_encode(
+    const grpc_gcp_rpc_protocol_versions* versions, grpc_slice* slice);
 
 /**
  * This method serializes an rpc protocol version and returns serialized rpc
  * versions in grpc slice.
  *
  * - versions: an rpc protocol versions instance.
+ * - arena: upb arena.
  * - slice: grpc slice where the serialized result will be written.
  *
  * The method returns true on success and false otherwise.
  */
 bool grpc_gcp_rpc_protocol_versions_encode(
-    const grpc_gcp_rpc_protocol_versions* versions, grpc_slice* slice);
+    const grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    grpc_slice* slice);
 
 /**
  * This method de-serializes input in grpc slice form and stores the result
@@ -114,6 +107,21 @@ bool grpc_gcp_rpc_protocol_versions_encode(
 bool grpc_gcp_rpc_protocol_versions_decode(
     const grpc_slice& slice, grpc_gcp_rpc_protocol_versions* versions);
 
+/**
+ * Assigns value of upb RpcProtocolVersions to grpc_gcp_rpc_protocol_versions.
+ */
+void grpc_gcp_rpc_protocol_versions_assign_from_upb(
+    grpc_gcp_rpc_protocol_versions* versions,
+    const grpc_gcp_RpcProtocolVersions* value);
+
+/**
+ * Assigns value of struct grpc_gcp_rpc_protocol_versions to
+ * RpcProtocolVersions.
+ */
+void grpc_gcp_RpcProtocolVersions_assign_from_struct(
+    grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    const grpc_gcp_rpc_protocol_versions* value);
+
 /**
  * This method performs a deep copy operation on rpc protocol versions
  * instance.

data/src/core/tsi/ssl_transport_security.cc

@@ -350,11 +350,19 @@ static tsi_result add_subject_alt_names_properties_to_peer(
   for (i = 0; i < subject_alt_name_count; i++) {
     GENERAL_NAME* subject_alt_name =
         sk_GENERAL_NAME_value(subject_alt_names, TSI_SIZE_AS_SIZE(i));
-    /* Filter out the non-dns entries names. */
-    if (subject_alt_name->type == GEN_DNS) {
+    if (subject_alt_name->type == GEN_DNS ||
+        subject_alt_name->type == GEN_EMAIL ||
+        subject_alt_name->type == GEN_URI) {
       unsigned char* name = nullptr;
       int name_size;
-      name_size = ASN1_STRING_to_UTF8(&name, subject_alt_name->d.dNSName);
+      if (subject_alt_name->type == GEN_DNS) {
+        name_size = ASN1_STRING_to_UTF8(&name, subject_alt_name->d.dNSName);
+      } else if (subject_alt_name->type == GEN_EMAIL) {
+        name_size = ASN1_STRING_to_UTF8(&name, subject_alt_name->d.rfc822Name);
+      } else {
+        name_size = ASN1_STRING_to_UTF8(
+            &name, subject_alt_name->d.uniformResourceIdentifier);
+      }
       if (name_size < 0) {
         gpr_log(GPR_ERROR, "Could not get utf8 from asn1 string.");
         result = TSI_INTERNAL_ERROR;
@@ -703,8 +711,8 @@ static tsi_result populate_ssl_context(
 }
 
 /* Extracts the CN and the SANs from an X509 cert as a peer object. */
-static tsi_result extract_x509_subject_names_from_pem_cert(const char* pem_cert,
-                                                           tsi_peer* peer) {
+tsi_result tsi_ssl_extract_x509_subject_names_from_pem_cert(
+    const char* pem_cert, tsi_peer* peer) {
   tsi_result result = TSI_OK;
   X509* cert = nullptr;
   BIO* pem;
@@ -1882,7 +1890,7 @@ tsi_result tsi_create_ssl_server_handshaker_factory_with_options(
       }
       /* TODO(jboeuf): Add revocation verification. */
 
-      result = extract_x509_subject_names_from_pem_cert(
+      result = tsi_ssl_extract_x509_subject_names_from_pem_cert(
           options->pem_key_cert_pairs[i].cert_chain,
           &impl->ssl_context_x509_subject_names[i]);
       if (result != TSI_OK) break;

data/src/core/tsi/ssl_transport_security.h

@@ -332,4 +332,8 @@ const tsi_ssl_handshaker_factory_vtable* tsi_ssl_handshaker_factory_swap_vtable(
     tsi_ssl_handshaker_factory* factory,
     tsi_ssl_handshaker_factory_vtable* new_vtable);
 
+/* Exposed for testing only. */
+tsi_result tsi_ssl_extract_x509_subject_names_from_pem_cert(
+    const char* pem_cert, tsi_peer* peer);
+
 #endif /* GRPC_CORE_TSI_SSL_TRANSPORT_SECURITY_H */

data/src/ruby/ext/grpc/ext-export.clang

@@ -0,0 +1 @@
+_Init_grpc_c

data/src/ruby/ext/grpc/ext-export.gcc

@@ -0,0 +1,6 @@
+grpc_1.0 { 
+  global: 
+    Init_grpc_c;
+  local: 
+    *;
+};

data/src/ruby/ext/grpc/extconf.rb

@@ -60,6 +60,11 @@ unless windows
 end
 
 $CFLAGS << ' -I' + File.join(grpc_root, 'include')
+
+ext_export_file = File.join(grpc_root, 'src', 'ruby', 'ext', 'grpc', 'ext-export')
+$LDFLAGS << ' -Wl,--version-script="' + ext_export_file + '.gcc"' if RUBY_PLATFORM =~ /linux/
+$LDFLAGS << ' -Wl,-exported_symbols_list,"' + ext_export_file + '.clang"' if RUBY_PLATFORM =~ /darwin/
+
 $LDFLAGS << ' ' + File.join(grpc_lib_dir, 'libgrpc.a') unless windows
 if grpc_config == 'gcov'
   $CFLAGS << ' -O0 -fprofile-arcs -ftest-coverage'

data/src/ruby/ext/grpc/rb_enable_cpp.cc

@@ -0,0 +1,22 @@
+/*
+ *
+ * Copyright 2019 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>
+
+// This is a dummy C++ source file to trigger ruby extension builder to
+// pick C++ rather than C linker to link with c++ library properly.

data/src/ruby/ext/grpc/rb_grpc.c

@@ -155,45 +155,6 @@ gpr_timespec grpc_rb_time_timeval(VALUE time, int interval) {
   return t;
 }
 
-static void Init_grpc_status_codes() {
-  /* Constants representing the status codes or grpc_status_code in status.h */
-  VALUE grpc_rb_mStatusCodes =
-      rb_define_module_under(grpc_rb_mGrpcCore, "StatusCodes");
-  rb_define_const(grpc_rb_mStatusCodes, "OK", INT2NUM(GRPC_STATUS_OK));
-  rb_define_const(grpc_rb_mStatusCodes, "CANCELLED",
-                  INT2NUM(GRPC_STATUS_CANCELLED));
-  rb_define_const(grpc_rb_mStatusCodes, "UNKNOWN",
-                  INT2NUM(GRPC_STATUS_UNKNOWN));
-  rb_define_const(grpc_rb_mStatusCodes, "INVALID_ARGUMENT",
-                  INT2NUM(GRPC_STATUS_INVALID_ARGUMENT));
-  rb_define_const(grpc_rb_mStatusCodes, "DEADLINE_EXCEEDED",
-                  INT2NUM(GRPC_STATUS_DEADLINE_EXCEEDED));
-  rb_define_const(grpc_rb_mStatusCodes, "NOT_FOUND",
-                  INT2NUM(GRPC_STATUS_NOT_FOUND));
-  rb_define_const(grpc_rb_mStatusCodes, "ALREADY_EXISTS",
-                  INT2NUM(GRPC_STATUS_ALREADY_EXISTS));
-  rb_define_const(grpc_rb_mStatusCodes, "PERMISSION_DENIED",
-                  INT2NUM(GRPC_STATUS_PERMISSION_DENIED));
-  rb_define_const(grpc_rb_mStatusCodes, "UNAUTHENTICATED",
-                  INT2NUM(GRPC_STATUS_UNAUTHENTICATED));
-  rb_define_const(grpc_rb_mStatusCodes, "RESOURCE_EXHAUSTED",
-                  INT2NUM(GRPC_STATUS_RESOURCE_EXHAUSTED));
-  rb_define_const(grpc_rb_mStatusCodes, "FAILED_PRECONDITION",
-                  INT2NUM(GRPC_STATUS_FAILED_PRECONDITION));
-  rb_define_const(grpc_rb_mStatusCodes, "ABORTED",
-                  INT2NUM(GRPC_STATUS_ABORTED));
-  rb_define_const(grpc_rb_mStatusCodes, "OUT_OF_RANGE",
-                  INT2NUM(GRPC_STATUS_OUT_OF_RANGE));
-  rb_define_const(grpc_rb_mStatusCodes, "UNIMPLEMENTED",
-                  INT2NUM(GRPC_STATUS_UNIMPLEMENTED));
-  rb_define_const(grpc_rb_mStatusCodes, "INTERNAL",
-                  INT2NUM(GRPC_STATUS_INTERNAL));
-  rb_define_const(grpc_rb_mStatusCodes, "UNAVAILABLE",
-                  INT2NUM(GRPC_STATUS_UNAVAILABLE));
-  rb_define_const(grpc_rb_mStatusCodes, "DATA_LOSS",
-                  INT2NUM(GRPC_STATUS_DATA_LOSS));
-}
-
 /* id_at is the constructor method of the ruby standard Time class. */
 static ID id_at;
 
@@ -351,8 +312,7 @@ void Init_grpc_c() {
   grpc_rb_mGrpcCore = rb_define_module_under(grpc_rb_mGRPC, "Core");
   grpc_rb_sNewServerRpc = rb_struct_define(
       "NewServerRpc", "method", "host", "deadline", "metadata", "call", NULL);
-  grpc_rb_sStatus =
-      rb_struct_define("Status", "code", "details", "metadata", NULL);
+  grpc_rb_sStatus = rb_const_get(rb_cStruct, rb_intern("Status"));
   sym_code = ID2SYM(rb_intern("code"));
   sym_details = ID2SYM(rb_intern("details"));
   sym_metadata = ID2SYM(rb_intern("metadata"));
@@ -363,7 +323,6 @@ void Init_grpc_c() {
   Init_grpc_channel_credentials();
   Init_grpc_server();
   Init_grpc_server_credentials();
-  Init_grpc_status_codes();
   Init_grpc_time_consts();
   Init_grpc_compression_options();
 }

data/src/ruby/ext/grpc/rb_grpc_imports.generated.c

@@ -164,6 +164,8 @@ grpc_tls_credentials_options_set_credential_reload_config_type grpc_tls_credenti
 grpc_tls_credentials_options_set_server_authorization_check_config_type grpc_tls_credentials_options_set_server_authorization_check_config_import;
 grpc_tls_key_materials_config_create_type grpc_tls_key_materials_config_create_import;
 grpc_tls_key_materials_config_set_key_materials_type grpc_tls_key_materials_config_set_key_materials_import;
+grpc_tls_key_materials_config_set_version_type grpc_tls_key_materials_config_set_version_import;
+grpc_tls_key_materials_config_get_version_type grpc_tls_key_materials_config_get_version_import;
 grpc_tls_credential_reload_config_create_type grpc_tls_credential_reload_config_create_import;
 grpc_tls_server_authorization_check_config_create_type grpc_tls_server_authorization_check_config_create_import;
 grpc_raw_byte_buffer_create_type grpc_raw_byte_buffer_create_import;
@@ -435,6 +437,8 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_tls_credentials_options_set_server_authorization_check_config_import = (grpc_tls_credentials_options_set_server_authorization_check_config_type) GetProcAddress(library, "grpc_tls_credentials_options_set_server_authorization_check_config");
   grpc_tls_key_materials_config_create_import = (grpc_tls_key_materials_config_create_type) GetProcAddress(library, "grpc_tls_key_materials_config_create");
   grpc_tls_key_materials_config_set_key_materials_import = (grpc_tls_key_materials_config_set_key_materials_type) GetProcAddress(library, "grpc_tls_key_materials_config_set_key_materials");
+  grpc_tls_key_materials_config_set_version_import = (grpc_tls_key_materials_config_set_version_type) GetProcAddress(library, "grpc_tls_key_materials_config_set_version");
+  grpc_tls_key_materials_config_get_version_import = (grpc_tls_key_materials_config_get_version_type) GetProcAddress(library, "grpc_tls_key_materials_config_get_version");
   grpc_tls_credential_reload_config_create_import = (grpc_tls_credential_reload_config_create_type) GetProcAddress(library, "grpc_tls_credential_reload_config_create");
   grpc_tls_server_authorization_check_config_create_import = (grpc_tls_server_authorization_check_config_create_type) GetProcAddress(library, "grpc_tls_server_authorization_check_config_create");
   grpc_raw_byte_buffer_create_import = (grpc_raw_byte_buffer_create_type) GetProcAddress(library, "grpc_raw_byte_buffer_create");

data/src/ruby/ext/grpc/rb_grpc_imports.generated.h

@@ -467,6 +467,12 @@ extern grpc_tls_key_materials_config_create_type grpc_tls_key_materials_config_c
 typedef int(*grpc_tls_key_materials_config_set_key_materials_type)(grpc_tls_key_materials_config* config, const char* pem_root_certs, const grpc_ssl_pem_key_cert_pair** pem_key_cert_pairs, size_t num_key_cert_pairs);
 extern grpc_tls_key_materials_config_set_key_materials_type grpc_tls_key_materials_config_set_key_materials_import;
 #define grpc_tls_key_materials_config_set_key_materials grpc_tls_key_materials_config_set_key_materials_import
+typedef int(*grpc_tls_key_materials_config_set_version_type)(grpc_tls_key_materials_config* config, int version);
+extern grpc_tls_key_materials_config_set_version_type grpc_tls_key_materials_config_set_version_import;
+#define grpc_tls_key_materials_config_set_version grpc_tls_key_materials_config_set_version_import
+typedef int(*grpc_tls_key_materials_config_get_version_type)(grpc_tls_key_materials_config* config);
+extern grpc_tls_key_materials_config_get_version_type grpc_tls_key_materials_config_get_version_import;
+#define grpc_tls_key_materials_config_get_version grpc_tls_key_materials_config_get_version_import
 typedef grpc_tls_credential_reload_config*(*grpc_tls_credential_reload_config_create_type)(const void* config_user_data, int (*schedule)(void* config_user_data, grpc_tls_credential_reload_arg* arg), void (*cancel)(void* config_user_data, grpc_tls_credential_reload_arg* arg), void (*destruct)(void* config_user_data));
 extern grpc_tls_credential_reload_config_create_type grpc_tls_credential_reload_config_create_import;
 #define grpc_tls_credential_reload_config_create grpc_tls_credential_reload_config_create_import