grpc 1.45.0 → 1.53.0

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

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
-
-#ifndef GRPC_CORE_TSI_ALTS_HANDSHAKER_TRANSPORT_SECURITY_COMMON_API_H
-#define GRPC_CORE_TSI_ALTS_HANDSHAKER_TRANSPORT_SECURITY_COMMON_API_H
+//
+//
+// Copyright 2018 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_TRANSPORT_SECURITY_COMMON_API_H
+#define GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_TRANSPORT_SECURITY_COMMON_API_H
 
 #include <grpc/support/port_platform.h>
 
@@ -26,6 +26,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/proto/grpc/gcp/transport_security_common.upb.h"
 
 // C struct coresponding to protobuf message RpcProtocolVersions.Version
@@ -40,113 +41,113 @@ typedef struct _grpc_gcp_RpcProtocolVersions {
   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
- * versions.
- *
- * - versions: an rpc protocol version instance.
- * - max_major: a major version of maximum supported RPC version.
- * - max_minor: a minor version of maximum supported RPC version.
- *
- * The method returns true on success and false otherwise.
- */
+///
+/// This method sets the value for max_rpc_versions field of rpc protocol
+/// versions.
+///
+///- versions: an rpc protocol version instance.
+///- max_major: a major version of maximum supported RPC version.
+///- max_minor: a minor version of maximum supported RPC version.
+///
+/// The method returns true on success and false otherwise.
+///
 bool grpc_gcp_rpc_protocol_versions_set_max(
     grpc_gcp_rpc_protocol_versions* versions, uint32_t max_major,
     uint32_t max_minor);
 
-/**
- * This method sets the value for min_rpc_versions field of rpc protocol
- * versions.
- *
- * - versions: an rpc protocol version instance.
- * - min_major: a major version of minimum supported RPC version.
- * - min_minor: a minor version of minimum supported RPC version.
- *
- * The method returns true on success and false otherwise.
- */
+///
+/// This method sets the value for min_rpc_versions field of rpc protocol
+/// versions.
+///
+///- versions: an rpc protocol version instance.
+///- min_major: a major version of minimum supported RPC version.
+///- min_minor: a minor version of minimum supported RPC version.
+///
+/// The method returns true on success and false otherwise.
+///
 bool grpc_gcp_rpc_protocol_versions_set_min(
     grpc_gcp_rpc_protocol_versions* versions, uint32_t min_major,
     uint32_t min_minor);
 
-/**
- * This method serializes an rpc protocol version and returns serialized rpc
- * versions in grpc slice.
- *
- * - versions: an rpc protocol versions instance.
- * - slice: grpc slice where the serialized result will be written.
- *
- * The method returns true on success and false otherwise.
- */
+///
+/// This method serializes an rpc protocol version and returns serialized rpc
+/// versions in grpc slice.
+///
+///- versions: an rpc protocol versions instance.
+///- 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);
 
-/**
- * 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.
- */
+///
+/// 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_RpcProtocolVersions* versions, upb_Arena* arena,
     grpc_slice* slice);
 
-/**
- * This method de-serializes input in grpc slice form and stores the result
- * in rpc protocol versions.
- *
- * - slice: a data stream containing a serialized rpc protocol version.
- * - versions: an rpc protocol version instance used to hold de-serialized
- *   result.
- *
- * The method returns true on success and false otherwise.
- */
+///
+/// This method de-serializes input in grpc slice form and stores the result
+/// in rpc protocol versions.
+///
+///- slice: a data stream containing a serialized rpc protocol version.
+///- versions: an rpc protocol version instance used to hold de-serialized
+///  result.
+///
+/// The method returns true on success and false otherwise.
+///
 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.
- */
+///
+/// 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.
- */
+///
+/// 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.
- *
- * - src: rpc protocol versions instance that needs to be copied.
- * - dst: rpc protocol versions instance that stores the copied result.
- *
- * The method returns true on success and false otherwise.
- */
+///
+/// This method performs a deep copy operation on rpc protocol versions
+/// instance.
+///
+///- src: rpc protocol versions instance that needs to be copied.
+///- dst: rpc protocol versions instance that stores the copied result.
+///
+/// The method returns true on success and false otherwise.
+///
 bool grpc_gcp_rpc_protocol_versions_copy(
     const grpc_gcp_rpc_protocol_versions* src,
     grpc_gcp_rpc_protocol_versions* dst);
 
-/**
- * This method performs a version check between local and peer rpc protocol
- * versions.
- *
- * - local_versions: local rpc protocol versions instance.
- * - peer_versions: peer rpc protocol versions instance.
- * - highest_common_version: an output parameter that will store the highest
- *   common rpc protocol version both parties agreed on.
- *
- * The method returns true if the check passes which means both parties agreed
- * on a common rpc protocol to use, and false otherwise.
- */
+///
+/// This method performs a version check between local and peer rpc protocol
+/// versions.
+///
+///- local_versions: local rpc protocol versions instance.
+///- peer_versions: peer rpc protocol versions instance.
+///- highest_common_version: an output parameter that will store the highest
+///  common rpc protocol version both parties agreed on.
+///
+/// The method returns true if the check passes which means both parties agreed
+/// on a common rpc protocol to use, and false otherwise.
+///
 bool grpc_gcp_rpc_protocol_versions_check(
     const grpc_gcp_rpc_protocol_versions* local_versions,
     const grpc_gcp_rpc_protocol_versions* peer_versions,
@@ -155,12 +156,12 @@ bool grpc_gcp_rpc_protocol_versions_check(
 namespace grpc_core {
 namespace internal {
 
-/**
- * Exposed for testing only.
- * The method returns 0 if v1 = v2,
- *            returns 1 if v1 > v2,
- *            returns -1 if v1 < v2.
- */
+///
+/// Exposed for testing only.
+/// The method returns 0 if v1 = v2,
+///           returns 1 if v1 > v2,
+///           returns -1 if v1 < v2.
+///
 int grpc_gcp_rpc_protocol_version_compare(
     const grpc_gcp_rpc_protocol_versions_version* v1,
     const grpc_gcp_rpc_protocol_versions_version* v2);
@@ -168,4 +169,4 @@ int grpc_gcp_rpc_protocol_version_compare(
 }  // namespace internal
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_TRANSPORT_SECURITY_COMMON_API_H */
+#endif  // GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_TRANSPORT_SECURITY_COMMON_API_H

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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 <grpc/support/port_platform.h>
 
@@ -25,11 +25,13 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
 
-/* Main struct for alts_grpc_integrity_only_record_protocol.  */
+// Main struct for alts_grpc_integrity_only_record_protocol.
 typedef struct alts_grpc_integrity_only_record_protocol {
   alts_grpc_record_protocol base;
   bool enable_extra_copy;
@@ -37,12 +39,12 @@ typedef struct alts_grpc_integrity_only_record_protocol {
   unsigned char* tag_buf;
 } alts_grpc_integrity_only_record_protocol;
 
-/* --- alts_grpc_record_protocol methods implementation. --- */
+// --- alts_grpc_record_protocol methods implementation. ---
 
 static tsi_result alts_grpc_integrity_only_extra_copy_protect(
     alts_grpc_record_protocol* rp, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices) {
-  /* Allocates memory for protected frame and copies data.  */
+  // Allocates memory for protected frame and copies data.
   size_t data_length = unprotected_slices->length;
   size_t protected_frame_size =
       unprotected_slices->length + rp->header_length + rp->tag_length;
@@ -53,7 +55,7 @@ static tsi_result alts_grpc_integrity_only_extra_copy_protect(
            GRPC_SLICE_LENGTH(unprotected_slices->slices[i]));
     data += GRPC_SLICE_LENGTH(unprotected_slices->slices[i]);
   }
-  /* Calls alts_iovec_record_protocol protect.  */
+  // Calls alts_iovec_record_protocol protect.
   char* error_details = nullptr;
   iovec_t header_iovec = {GRPC_SLICE_START_PTR(protected_slice),
                           rp->header_length};
@@ -71,14 +73,14 @@ static tsi_result alts_grpc_integrity_only_extra_copy_protect(
     return TSI_INTERNAL_ERROR;
   }
   grpc_slice_buffer_add(protected_slices, protected_slice);
-  grpc_slice_buffer_reset_and_unref_internal(unprotected_slices);
+  grpc_slice_buffer_reset_and_unref(unprotected_slices);
   return TSI_OK;
 }
 
 static tsi_result alts_grpc_integrity_only_protect(
     alts_grpc_record_protocol* rp, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices) {
-  /* Input sanity check.  */
+  // Input sanity check.
   if (rp == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
     gpr_log(GPR_ERROR,
@@ -91,10 +93,10 @@ static tsi_result alts_grpc_integrity_only_protect(
     return alts_grpc_integrity_only_extra_copy_protect(rp, unprotected_slices,
                                                        protected_slices);
   }
-  /* Allocates memory for header and tag slices.  */
+  // Allocates memory for header and tag slices.
   grpc_slice header_slice = GRPC_SLICE_MALLOC(rp->header_length);
   grpc_slice tag_slice = GRPC_SLICE_MALLOC(rp->tag_length);
-  /* Calls alts_iovec_record_protocol protect.  */
+  // Calls alts_iovec_record_protocol protect.
   char* error_details = nullptr;
   iovec_t header_iovec = {GRPC_SLICE_START_PTR(header_slice),
                           GRPC_SLICE_LENGTH(header_slice)};
@@ -110,7 +112,7 @@ static tsi_result alts_grpc_integrity_only_protect(
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }
-  /* Appends result to protected_slices.  */
+  // Appends result to protected_slices.
   grpc_slice_buffer_add(protected_slices, header_slice);
   grpc_slice_buffer_move_into(unprotected_slices, protected_slices);
   grpc_slice_buffer_add(protected_slices, tag_slice);
@@ -120,7 +122,7 @@ static tsi_result alts_grpc_integrity_only_protect(
 static tsi_result alts_grpc_integrity_only_unprotect(
     alts_grpc_record_protocol* rp, grpc_slice_buffer* protected_slices,
     grpc_slice_buffer* unprotected_slices) {
-  /* Input sanity check.  */
+  // Input sanity check.
   if (rp == nullptr || protected_slices == nullptr ||
       unprotected_slices == nullptr) {
     gpr_log(
@@ -132,20 +134,19 @@ static tsi_result alts_grpc_integrity_only_unprotect(
     gpr_log(GPR_ERROR, "Protected slices do not have sufficient data.");
     return TSI_INVALID_ARGUMENT;
   }
-  /* In this method, rp points to alts_grpc_record_protocol struct
-   * and integrity_only_record_protocol points to
-   * alts_grpc_integrity_only_record_protocol struct.  */
+  // In this method, rp points to alts_grpc_record_protocol struct
+  // and integrity_only_record_protocol points to
+  // alts_grpc_integrity_only_record_protocol struct.
   alts_grpc_integrity_only_record_protocol* integrity_only_record_protocol =
       reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp);
-  /* Strips frame header from protected slices.  */
-  grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
+  // Strips frame header from protected slices.
+  grpc_slice_buffer_reset_and_unref(&rp->header_sb);
   grpc_slice_buffer_move_first(protected_slices, rp->header_length,
                                &rp->header_sb);
   GPR_ASSERT(rp->header_sb.length == rp->header_length);
   iovec_t header_iovec = alts_grpc_record_protocol_get_header_iovec(rp);
-  /* Moves protected slices data to data_sb and leaves the remaining tag.  */
-  grpc_slice_buffer_reset_and_unref_internal(
-      &integrity_only_record_protocol->data_sb);
+  // Moves protected slices data to data_sb and leaves the remaining tag.
+  grpc_slice_buffer_reset_and_unref(&integrity_only_record_protocol->data_sb);
   grpc_slice_buffer_move_first(protected_slices,
                                protected_slices->length - rp->tag_length,
                                &integrity_only_record_protocol->data_sb);
@@ -154,13 +155,13 @@ static tsi_result alts_grpc_integrity_only_unprotect(
   if (protected_slices->count == 1) {
     tag_iovec.iov_base = GRPC_SLICE_START_PTR(protected_slices->slices[0]);
   } else {
-    /* Frame tag is in multiple slices, copies the tag bytes from slice
-     * buffer to a single flat buffer.  */
+    // Frame tag is in multiple slices, copies the tag bytes from slice
+    // buffer to a single flat buffer.
     alts_grpc_record_protocol_copy_slice_buffer(
         protected_slices, integrity_only_record_protocol->tag_buf);
     tag_iovec.iov_base = integrity_only_record_protocol->tag_buf;
   }
-  /* Calls alts_iovec_record_protocol unprotect.  */
+  // Calls alts_iovec_record_protocol unprotect.
   char* error_details = nullptr;
   alts_grpc_record_protocol_convert_slice_buffer_to_iovec(
       rp, &integrity_only_record_protocol->data_sb);
@@ -173,8 +174,8 @@ static tsi_result alts_grpc_integrity_only_unprotect(
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }
-  grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
-  grpc_slice_buffer_reset_and_unref_internal(protected_slices);
+  grpc_slice_buffer_reset_and_unref(&rp->header_sb);
+  grpc_slice_buffer_reset_and_unref(protected_slices);
   grpc_slice_buffer_move_into(&integrity_only_record_protocol->data_sb,
                               unprotected_slices);
   return TSI_OK;
@@ -186,7 +187,7 @@ static void alts_grpc_integrity_only_destruct(alts_grpc_record_protocol* rp) {
   }
   alts_grpc_integrity_only_record_protocol* integrity_only_rp =
       reinterpret_cast<alts_grpc_integrity_only_record_protocol*>(rp);
-  grpc_slice_buffer_destroy_internal(&integrity_only_rp->data_sb);
+  grpc_slice_buffer_destroy(&integrity_only_rp->data_sb);
   gpr_free(integrity_only_rp->tag_buf);
 }
 
@@ -206,7 +207,7 @@ tsi_result alts_grpc_integrity_only_record_protocol_create(
   alts_grpc_integrity_only_record_protocol* impl =
       static_cast<alts_grpc_integrity_only_record_protocol*>(
           gpr_zalloc(sizeof(alts_grpc_integrity_only_record_protocol)));
-  /* Calls alts_grpc_record_protocol init.  */
+  // Calls alts_grpc_record_protocol init.
   tsi_result result = alts_grpc_record_protocol_init(
       &impl->base, crypter, overflow_size, is_client,
       /*is_integrity_only=*/true, is_protect);
@@ -215,9 +216,9 @@ tsi_result alts_grpc_integrity_only_record_protocol_create(
     return result;
   }
   impl->enable_extra_copy = enable_extra_copy;
-  /* Initializes slice buffer for data_sb.  */
+  // Initializes slice buffer for data_sb.
   grpc_slice_buffer_init(&impl->data_sb);
-  /* Allocates tag buffer.  */
+  // Allocates tag buffer.
   impl->tag_buf =
       static_cast<unsigned char*>(gpr_malloc(impl->base.tag_length));
   impl->base.vtable = &alts_grpc_integrity_only_record_protocol_vtable;

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_integrity_only_record_protocol.h

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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.
+//
+//
 
-#ifndef GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_INTEGRITY_ONLY_RECORD_PROTOCOL_H
-#define GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_INTEGRITY_ONLY_RECORD_PROTOCOL_H
+#ifndef GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_INTEGRITY_ONLY_RECORD_PROTOCOL_H
+#define GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_INTEGRITY_ONLY_RECORD_PROTOCOL_H
 
 #include <grpc/support/port_platform.h>
 
@@ -26,29 +26,28 @@
 #include "src/core/tsi/alts/crypt/gsec.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol.h"
 
-/**
- * This method creates an integrity-only alts_grpc_record_protocol instance,
- * given a gsec_aead_crypter instance and a flag indicating if the created
- * instance will be used at the client or server side. The ownership of
- * gsec_aead_crypter instance is transferred to this new object.
- *
- * - crypter: a gsec_aead_crypter instance used to perform AEAD decryption.
- * - overflow_size: overflow size of counter in bytes.
- * - is_client: a flag indicating if the alts_grpc_record_protocol instance will
- *   be used at the client or server side.
- * - is_protect: a flag indicating if the alts_grpc_record_protocol instance
- *   will be used for protect or unprotect.
- *-  enable_extra_copy: a flag indicating if the instance uses one-copy instead
- *   of zero-copy in the protect operation.
- * - rp: an alts_grpc_record_protocol instance to be returned from
- *   the method.
- *
- * This method returns TSI_OK in case of success or a specific error code in
- * case of failure.
- */
+///
+/// This method creates an integrity-only alts_grpc_record_protocol instance,
+/// given a gsec_aead_crypter instance and a flag indicating if the created
+/// instance will be used at the client or server side. The ownership of
+/// gsec_aead_crypter instance is transferred to this new object.
+///
+///- crypter: a gsec_aead_crypter instance used to perform AEAD decryption.
+///- overflow_size: overflow size of counter in bytes.
+///- is_client: a flag indicating if the alts_grpc_record_protocol instance will
+///  be used at the client or server side.
+///- is_protect: a flag indicating if the alts_grpc_record_protocol instance
+///  will be used for protect or unprotect.
+///-  enable_extra_copy: a flag indicating if the instance uses one-copy instead
+///  of zero-copy in the protect operation.
+///- rp: an alts_grpc_record_protocol instance to be returned from
+///  the method.
+///
+/// This method returns TSI_OK in case of success or a specific error code in
+/// case of failure.
+///
 tsi_result alts_grpc_integrity_only_record_protocol_create(
     gsec_aead_crypter* crypter, size_t overflow_size, bool is_client,
     bool is_protect, bool enable_extra_copy, alts_grpc_record_protocol** rp);
 
-#endif /* GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_INTEGRITY_ONLY_RECORD_PROTOCOL_H \
-        */
+#endif  // GRPC_SRC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_INTEGRITY_ONLY_RECORD_PROTOCOL_H