grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -1,36 +1,36 @@
-/*
- *
- * 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_RECORD_PROTOCOL_COMMON_H
 #define GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_COMMON_H
 
-/**
- * this file contains alts_grpc_record_protocol internals and internal-only
- * helper functions. The public functions of alts_grpc_record_protocol are
- * defined in the alts_grpc_record_protocol.h.
- */
+///
+/// this file contains alts_grpc_record_protocol internals and internal-only
+/// helper functions. The public functions of alts_grpc_record_protocol are
+/// defined in the alts_grpc_record_protocol.h.
+///
 
 #include <grpc/support/port_platform.h>
 
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
 
-/* V-table for alts_grpc_record_protocol implementations.  */
+// V-table for alts_grpc_record_protocol implementations.
 struct alts_grpc_record_protocol_vtable {
   tsi_result (*protect)(alts_grpc_record_protocol* self,
                         grpc_slice_buffer* unprotected_slices,
@@ -40,10 +40,10 @@ struct alts_grpc_record_protocol_vtable {
                           grpc_slice_buffer* unprotected_slices);
   void (*destruct)(alts_grpc_record_protocol* self);
 };
-/* Main struct for alts_grpc_record_protocol implementation, shared by both
- * integrity-only record protocol and privacy-integrity record protocol.
- * Integrity-only record protocol has additional data elements.
- * Privacy-integrity record protocol uses this struct directly.  */
+// Main struct for alts_grpc_record_protocol implementation, shared by both
+// integrity-only record protocol and privacy-integrity record protocol.
+// Integrity-only record protocol has additional data elements.
+// Privacy-integrity record protocol uses this struct directly.
 struct alts_grpc_record_protocol {
   const alts_grpc_record_protocol_vtable* vtable;
   alts_iovec_record_protocol* iovec_rp;
@@ -55,45 +55,44 @@ struct alts_grpc_record_protocol {
   size_t iovec_buf_length;
 };
 
-/**
- * Converts the slices of input sb into iovec_t's and puts the result into
- * rp->iovec_buf. Note that the actual data are not copied, only
- * pointers and lengths are copied.
- */
+///
+/// Converts the slices of input sb into iovec_t's and puts the result into
+/// rp->iovec_buf. Note that the actual data are not copied, only
+/// pointers and lengths are copied.
+///
 void alts_grpc_record_protocol_convert_slice_buffer_to_iovec(
     alts_grpc_record_protocol* rp, const grpc_slice_buffer* sb);
 
-/**
- * Copies bytes from slice buffer to destination buffer. Caller is responsible
- * for allocating enough memory of destination buffer. This method is used for
- * copying frame header and tag in case they are stored in multiple slices.
- */
+///
+/// Copies bytes from slice buffer to destination buffer. Caller is responsible
+/// for allocating enough memory of destination buffer. This method is used for
+/// copying frame header and tag in case they are stored in multiple slices.
+///
 void alts_grpc_record_protocol_copy_slice_buffer(const grpc_slice_buffer* src,
                                                  unsigned char* dst);
 
-/**
- * This method returns an iovec object pointing to the frame header stored in
- * rp->header_sb. If the frame header is stored in multiple slices,
- * this method will copy the bytes in rp->header_sb to
- * rp->header_buf, and return an iovec object pointing to
- * rp->header_buf.
- */
+///
+/// This method returns an iovec object pointing to the frame header stored in
+/// rp->header_sb. If the frame header is stored in multiple slices,
+/// this method will copy the bytes in rp->header_sb to
+/// rp->header_buf, and return an iovec object pointing to
+/// rp->header_buf.
+///
 iovec_t alts_grpc_record_protocol_get_header_iovec(
     alts_grpc_record_protocol* rp);
 
-/**
- * Initializes an alts_grpc_record_protocol object, given a gsec_aead_crypter
- * instance, the overflow size of the counter in bytes, a flag indicating if the
- * object is used for client or server side, a flag indicating if it is used for
- * integrity-only or privacy-integrity mode, and a flag indicating if it is for
- * protect or unprotect. The ownership of gsec_aead_crypter object is
- * transferred to the alts_grpc_record_protocol object.
- */
+///
+/// Initializes an alts_grpc_record_protocol object, given a gsec_aead_crypter
+/// instance, the overflow size of the counter in bytes, a flag indicating if
+/// the object is used for client or server side, a flag indicating if it is
+/// used for integrity-only or privacy-integrity mode, and a flag indicating if
+/// it is for protect or unprotect. The ownership of gsec_aead_crypter object is
+/// transferred to the alts_grpc_record_protocol object.
+///
 tsi_result alts_grpc_record_protocol_init(alts_grpc_record_protocol* rp,
                                           gsec_aead_crypter* crypter,
                                           size_t overflow_size, bool is_client,
                                           bool is_integrity_only,
                                           bool is_protect);
 
-#endif /* GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_COMMON_H \
-        */
+#endif  // GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_COMMON_H

data/src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_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>
 
@@ -26,6 +26,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/tsi/alts/frame_protector/alts_counter.h"
 
 struct alts_iovec_record_protocol {
@@ -36,7 +37,7 @@ struct alts_iovec_record_protocol {
   bool is_protect;
 };
 
-/* Copies error message to destination.  */
+// Copies error message to destination.
 static void maybe_copy_error_msg(const char* src, char** dst) {
   if (dst != nullptr && src != nullptr) {
     *dst = static_cast<char*>(gpr_malloc(strlen(src) + 1));
@@ -44,7 +45,7 @@ static void maybe_copy_error_msg(const char* src, char** dst) {
   }
 }
 
-/* Appends error message to destination.  */
+// Appends error message to destination.
 static void maybe_append_error_msg(const char* appendix, char** dst) {
   if (dst != nullptr && appendix != nullptr) {
     int dst_len = static_cast<int>(strlen(*dst));
@@ -54,7 +55,7 @@ static void maybe_append_error_msg(const char* appendix, char** dst) {
   }
 }
 
-/* Use little endian to interpret a string of bytes as uint32_t.  */
+// Use little endian to interpret a string of bytes as uint32_t.
 static uint32_t load_32_le(const unsigned char* buffer) {
   return (static_cast<uint32_t>(buffer[3]) << 24) |
          (static_cast<uint32_t>(buffer[2]) << 16) |
@@ -62,7 +63,7 @@ static uint32_t load_32_le(const unsigned char* buffer) {
          static_cast<uint32_t>(buffer[0]);
 }
 
-/* Store uint32_t as a string of little endian bytes.  */
+// Store uint32_t as a string of little endian bytes.
 static void store_32_le(uint32_t value, unsigned char* buffer) {
   buffer[3] = static_cast<unsigned char>(value >> 24) & 0xFF;
   buffer[2] = static_cast<unsigned char>(value >> 16) & 0xFF;
@@ -70,7 +71,7 @@ static void store_32_le(uint32_t value, unsigned char* buffer) {
   buffer[0] = static_cast<unsigned char>(value) & 0xFF;
 }
 
-/* Ensures header and tag iovec have sufficient length.  */
+// Ensures header and tag iovec have sufficient length.
 static grpc_status_code ensure_header_and_tag_length(
     const alts_iovec_record_protocol* rp, iovec_t header, iovec_t tag,
     char** error_details) {
@@ -96,7 +97,7 @@ static grpc_status_code ensure_header_and_tag_length(
   return GRPC_STATUS_OK;
 }
 
-/* Increments crypter counter and checks overflow.  */
+// Increments crypter counter and checks overflow.
 static grpc_status_code increment_counter(alts_counter* counter,
                                           char** error_details) {
   if (counter == nullptr) {
@@ -115,7 +116,7 @@ static grpc_status_code increment_counter(alts_counter* counter,
   return GRPC_STATUS_OK;
 }
 
-/* Given an array of iovec, computes the total length of buffer.  */
+// Given an array of iovec, computes the total length of buffer.
 static size_t get_total_length(const iovec_t* vec, size_t vec_length) {
   size_t total_length = 0;
   for (size_t i = 0; i < vec_length; ++i) {
@@ -124,7 +125,7 @@ static size_t get_total_length(const iovec_t* vec, size_t vec_length) {
   return total_length;
 }
 
-/* Writes frame header given data and tag length.  */
+// Writes frame header given data and tag length.
 static grpc_status_code write_frame_header(size_t data_length,
                                            unsigned char* header,
                                            char** error_details) {
@@ -139,7 +140,7 @@ static grpc_status_code write_frame_header(size_t data_length,
   return GRPC_STATUS_OK;
 }
 
-/* Verifies frame header given protected data length.  */
+// Verifies frame header given protected data length.
 static grpc_status_code verify_frame_header(size_t data_length,
                                             unsigned char* header,
                                             char** error_details) {
@@ -160,7 +161,7 @@ static grpc_status_code verify_frame_header(size_t data_length,
   return GRPC_STATUS_OK;
 }
 
-/* --- alts_iovec_record_protocol methods implementation. --- */
+// --- alts_iovec_record_protocol methods implementation. ---
 
 size_t alts_iovec_record_protocol_get_header_length() {
   return kZeroCopyFrameHeaderSize;
@@ -189,7 +190,7 @@ grpc_status_code alts_iovec_record_protocol_integrity_only_protect(
     alts_iovec_record_protocol* rp, const iovec_t* unprotected_vec,
     size_t unprotected_vec_length, iovec_t header, iovec_t tag,
     char** error_details) {
-  /* Input sanity checks.  */
+  // Input sanity checks.
   if (rp == nullptr) {
     maybe_copy_error_msg("Input iovec_record_protocol is nullptr.",
                          error_details);
@@ -211,17 +212,17 @@ grpc_status_code alts_iovec_record_protocol_integrity_only_protect(
   if (status != GRPC_STATUS_OK) {
     return status;
   }
-  /* Unprotected data should not be zero length.  */
+  // Unprotected data should not be zero length.
   size_t data_length =
       get_total_length(unprotected_vec, unprotected_vec_length);
-  /* Sets frame header.  */
+  // Sets frame header.
   status = write_frame_header(data_length + rp->tag_length,
                               static_cast<unsigned char*>(header.iov_base),
                               error_details);
   if (status != GRPC_STATUS_OK) {
     return status;
   }
-  /* Computes frame tag by calling AEAD crypter.  */
+  // Computes frame tag by calling AEAD crypter.
   size_t bytes_written = 0;
   status = gsec_aead_crypter_encrypt_iovec(
       rp->crypter, alts_counter_get_counter(rp->ctr),
@@ -236,7 +237,7 @@ grpc_status_code alts_iovec_record_protocol_integrity_only_protect(
                          error_details);
     return GRPC_STATUS_INTERNAL;
   }
-  /* Increments the crypter counter.  */
+  // Increments the crypter counter.
   return increment_counter(rp->ctr, error_details);
 }
 
@@ -244,7 +245,7 @@ grpc_status_code alts_iovec_record_protocol_integrity_only_unprotect(
     alts_iovec_record_protocol* rp, const iovec_t* protected_vec,
     size_t protected_vec_length, iovec_t header, iovec_t tag,
     char** error_details) {
-  /* Input sanity checks.  */
+  // Input sanity checks.
   if (rp == nullptr) {
     maybe_copy_error_msg("Input iovec_record_protocol is nullptr.",
                          error_details);
@@ -264,16 +265,16 @@ grpc_status_code alts_iovec_record_protocol_integrity_only_unprotect(
   grpc_status_code status =
       ensure_header_and_tag_length(rp, header, tag, error_details);
   if (status != GRPC_STATUS_OK) return status;
-  /* Protected data should not be zero length.  */
+  // Protected data should not be zero length.
   size_t data_length = get_total_length(protected_vec, protected_vec_length);
-  /* Verifies frame header.  */
+  // Verifies frame header.
   status = verify_frame_header(data_length + rp->tag_length,
                                static_cast<unsigned char*>(header.iov_base),
                                error_details);
   if (status != GRPC_STATUS_OK) {
     return status;
   }
-  /* Verifies frame tag by calling AEAD crypter.  */
+  // Verifies frame tag by calling AEAD crypter.
   iovec_t plaintext = {nullptr, 0};
   size_t bytes_written = 0;
   status = gsec_aead_crypter_decrypt_iovec(
@@ -284,7 +285,7 @@ grpc_status_code alts_iovec_record_protocol_integrity_only_unprotect(
     maybe_append_error_msg(" Frame tag verification failed.", error_details);
     return GRPC_STATUS_INTERNAL;
   }
-  /* Increments the crypter counter.  */
+  // Increments the crypter counter.
   return increment_counter(rp->ctr, error_details);
 }
 
@@ -292,7 +293,7 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_protect(
     alts_iovec_record_protocol* rp, const iovec_t* unprotected_vec,
     size_t unprotected_vec_length, iovec_t protected_frame,
     char** error_details) {
-  /* Input sanity checks.  */
+  // Input sanity checks.
   if (rp == nullptr) {
     maybe_copy_error_msg("Input iovec_record_protocol is nullptr.",
                          error_details);
@@ -309,10 +310,10 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_protect(
                          error_details);
     return GRPC_STATUS_FAILED_PRECONDITION;
   }
-  /* Unprotected data should not be zero length.  */
+  // Unprotected data should not be zero length.
   size_t data_length =
       get_total_length(unprotected_vec, unprotected_vec_length);
-  /* Ensures protected frame iovec has sufficient size.  */
+  // Ensures protected frame iovec has sufficient size.
   if (protected_frame.iov_base == nullptr) {
     maybe_copy_error_msg("Protected frame is nullptr.", error_details);
     return GRPC_STATUS_INVALID_ARGUMENT;
@@ -323,14 +324,14 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_protect(
     maybe_copy_error_msg("Protected frame size is incorrect.", error_details);
     return GRPC_STATUS_INVALID_ARGUMENT;
   }
-  /* Writer frame header.  */
+  // Writer frame header.
   grpc_status_code status = write_frame_header(
       data_length + rp->tag_length,
       static_cast<unsigned char*>(protected_frame.iov_base), error_details);
   if (status != GRPC_STATUS_OK) {
     return status;
   }
-  /* Encrypt unprotected data by calling AEAD crypter.  */
+  // Encrypt unprotected data by calling AEAD crypter.
   unsigned char* ciphertext_buffer =
       static_cast<unsigned char*>(protected_frame.iov_base) +
       alts_iovec_record_protocol_get_header_length();
@@ -350,7 +351,7 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_protect(
         error_details);
     return GRPC_STATUS_INTERNAL;
   }
-  /* Increments the crypter counter. */
+  // Increments the crypter counter.
   return increment_counter(rp->ctr, error_details);
 }
 
@@ -358,7 +359,7 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_unprotect(
     alts_iovec_record_protocol* rp, iovec_t header,
     const iovec_t* protected_vec, size_t protected_vec_length,
     iovec_t unprotected_data, char** error_details) {
-  /* Input sanity checks.  */
+  // Input sanity checks.
   if (rp == nullptr) {
     maybe_copy_error_msg("Input iovec_record_protocol is nullptr.",
                          error_details);
@@ -375,7 +376,7 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_unprotect(
         "Unprotect operations are not allowed for this object.", error_details);
     return GRPC_STATUS_FAILED_PRECONDITION;
   }
-  /* Protected data size should be no less than tag size.  */
+  // Protected data size should be no less than tag size.
   size_t protected_data_length =
       get_total_length(protected_vec, protected_vec_length);
   if (protected_data_length < rp->tag_length) {
@@ -384,7 +385,7 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_unprotect(
         error_details);
     return GRPC_STATUS_INVALID_ARGUMENT;
   }
-  /* Ensures header has sufficient size.  */
+  // Ensures header has sufficient size.
   if (header.iov_base == nullptr) {
     maybe_copy_error_msg("Header is nullptr.", error_details);
     return GRPC_STATUS_INVALID_ARGUMENT;
@@ -393,19 +394,19 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_unprotect(
     maybe_copy_error_msg("Header length is incorrect.", error_details);
     return GRPC_STATUS_INVALID_ARGUMENT;
   }
-  /* Ensures unprotected data iovec has sufficient size.  */
+  // Ensures unprotected data iovec has sufficient size.
   if (unprotected_data.iov_len != protected_data_length - rp->tag_length) {
     maybe_copy_error_msg("Unprotected data size is incorrect.", error_details);
     return GRPC_STATUS_INVALID_ARGUMENT;
   }
-  /* Verify frame header.  */
+  // Verify frame header.
   grpc_status_code status = verify_frame_header(
       protected_data_length, static_cast<unsigned char*>(header.iov_base),
       error_details);
   if (status != GRPC_STATUS_OK) {
     return status;
   }
-  /* Decrypt protected data by calling AEAD crypter.  */
+  // Decrypt protected data by calling AEAD crypter.
   size_t bytes_written = 0;
   status = gsec_aead_crypter_decrypt_iovec(
       rp->crypter, alts_counter_get_counter(rp->ctr),
@@ -422,7 +423,7 @@ grpc_status_code alts_iovec_record_protocol_privacy_integrity_unprotect(
         error_details);
     return GRPC_STATUS_INTERNAL;
   }
-  /* Increments the crypter counter. */
+  // Increments the crypter counter.
   return increment_counter(rp->ctr, error_details);
 }
 
@@ -438,21 +439,21 @@ grpc_status_code alts_iovec_record_protocol_create(
   }
   alts_iovec_record_protocol* impl = static_cast<alts_iovec_record_protocol*>(
       gpr_zalloc(sizeof(alts_iovec_record_protocol)));
-  /* Gets counter length.  */
+  // Gets counter length.
   size_t counter_length = 0;
   grpc_status_code status =
       gsec_aead_crypter_nonce_length(crypter, &counter_length, error_details);
   if (status != GRPC_STATUS_OK) {
     goto cleanup;
   }
-  /* Creates counters.  */
+  // Creates counters.
   status =
       alts_counter_create(is_protect ? !is_client : is_client, counter_length,
                           overflow_size, &impl->ctr, error_details);
   if (status != GRPC_STATUS_OK) {
     goto cleanup;
   }
-  /* Gets tag length.  */
+  // Gets tag length.
   status =
       gsec_aead_crypter_tag_length(crypter, &impl->tag_length, error_details);
   if (status != GRPC_STATUS_OK) {