grpc 1.51.0 → 1.52.0

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

@@ -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.
+//
+//
 
 #ifndef GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H
 #define GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H
@@ -26,24 +26,23 @@
 #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 a privacy-integrity 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.
- * - is_client: a flag indicating if the alts_grpc_record_protocol instance will
- *   be used at the client or server side.
- * - 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 a privacy-integrity 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.
+///- is_client: a flag indicating if the alts_grpc_record_protocol instance will
+///  be used at the client or server side.
+///- 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_privacy_integrity_record_protocol_create(
     gsec_aead_crypter* crypter, size_t overflow_size, bool is_client,
     bool is_protect, alts_grpc_record_protocol** rp);
 
-#endif /* GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H \
-        */
+#endif  // GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_PRIVACY_INTEGRITY_RECORD_PROTOCOL_H

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

@@ -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.
+//
+//
 
 #ifndef GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H
 #define GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H
@@ -25,67 +25,66 @@
 
 #include "src/core/tsi/transport_security_interface.h"
 
-/**
- * This alts_grpc_record_protocol object protects and unprotects a single frame
- * stored in grpc slice buffer with zero or minimized memory copy.
- * Implementations of this object must be thread compatible.
- */
+///
+/// This alts_grpc_record_protocol object protects and unprotects a single frame
+/// stored in grpc slice buffer with zero or minimized memory copy.
+/// Implementations of this object must be thread compatible.
+///
 typedef struct alts_grpc_record_protocol alts_grpc_record_protocol;
 
-/**
- * This methods performs protect operation on unprotected data and appends the
- * protected frame to protected_slices. The caller needs to ensure the length
- * of unprotected data plus the frame overhead is less than or equal to the
- * maximum frame length. The input unprotected data slice buffer will be
- * cleared, although the actual unprotected data bytes are not modified.
- *
- * - self: an alts_grpc_record_protocol instance.
- * - unprotected_slices: the unprotected data to be protected.
- * - protected_slices: slice buffer where the protected frame is appended.
- *
- * This method returns TSI_OK in case of success or a specific error code in
- * case of failure.
- */
+///
+/// This methods performs protect operation on unprotected data and appends the
+/// protected frame to protected_slices. The caller needs to ensure the length
+/// of unprotected data plus the frame overhead is less than or equal to the
+/// maximum frame length. The input unprotected data slice buffer will be
+/// cleared, although the actual unprotected data bytes are not modified.
+///
+///- self: an alts_grpc_record_protocol instance.
+///- unprotected_slices: the unprotected data to be protected.
+///- protected_slices: slice buffer where the protected frame is appended.
+///
+/// This method returns TSI_OK in case of success or a specific error code in
+/// case of failure.
+///
 tsi_result alts_grpc_record_protocol_protect(
     alts_grpc_record_protocol* self, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices);
 
-/**
- * This methods performs unprotect operation on a full frame of protected data
- * and appends unprotected data to unprotected_slices. It is the caller's
- * responsibility to prepare a full frame of data before calling this method.
- * The input protected frame slice buffer will be cleared, although the actual
- * protected data bytes are not modified.
- *
- * - self: an alts_grpc_record_protocol instance.
- * - protected_slices: a full frame of protected data in grpc slices.
- * - unprotected_slices: slice buffer where unprotected data is appended.
- *
- * This method returns TSI_OK in case of success or a specific error code in
- * case of failure.
- */
+///
+/// This methods performs unprotect operation on a full frame of protected data
+/// and appends unprotected data to unprotected_slices. It is the caller's
+/// responsibility to prepare a full frame of data before calling this method.
+/// The input protected frame slice buffer will be cleared, although the actual
+/// protected data bytes are not modified.
+///
+///- self: an alts_grpc_record_protocol instance.
+///- protected_slices: a full frame of protected data in grpc slices.
+///- unprotected_slices: slice buffer where unprotected data is appended.
+///
+/// This method returns TSI_OK in case of success or a specific error code in
+/// case of failure.
+///
 tsi_result alts_grpc_record_protocol_unprotect(
     alts_grpc_record_protocol* self, grpc_slice_buffer* protected_slices,
     grpc_slice_buffer* unprotected_slices);
 
-/**
- * This method returns maximum allowed unprotected data size, given maximum
- * protected frame size.
- *
- * - self: an alts_grpc_record_protocol instance.
- * - max_protected_frame_size: maximum protected frame size.
- *
- * On success, the method returns the maximum allowed unprotected data size.
- * Otherwise, it returns zero.
- */
+///
+/// This method returns maximum allowed unprotected data size, given maximum
+/// protected frame size.
+///
+///- self: an alts_grpc_record_protocol instance.
+///- max_protected_frame_size: maximum protected frame size.
+///
+/// On success, the method returns the maximum allowed unprotected data size.
+/// Otherwise, it returns zero.
+///
 size_t alts_grpc_record_protocol_max_unprotected_data_size(
     const alts_grpc_record_protocol* self, size_t max_protected_frame_size);
 
-/**
- * This method destroys an alts_grpc_record_protocol instance by de-allocating
- * all of its occupied memory.
- */
+///
+/// This method destroys an alts_grpc_record_protocol instance by de-allocating
+/// all of its occupied memory.
+///
 void alts_grpc_record_protocol_destroy(alts_grpc_record_protocol* self);
 
-#endif /* GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H \
-        */
+#endif  // GRPC_CORE_TSI_ALTS_ZERO_COPY_FRAME_PROTECTOR_ALTS_GRPC_RECORD_PROTOCOL_H

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.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,26 +26,27 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 const size_t kInitialIovecBufferSize = 8;
 
-/* Makes sure iovec_buf in alts_grpc_record_protocol is large enough.  */
+// Makes sure iovec_buf in alts_grpc_record_protocol is large enough.
 static void ensure_iovec_buf_size(alts_grpc_record_protocol* rp,
                                   const grpc_slice_buffer* sb) {
   GPR_ASSERT(rp != nullptr && sb != nullptr);
   if (sb->count <= rp->iovec_buf_length) {
     return;
   }
-  /* At least double the iovec buffer size.  */
+  // At least double the iovec buffer size.
   rp->iovec_buf_length = std::max(sb->count, 2 * rp->iovec_buf_length);
   rp->iovec_buf = static_cast<iovec_t*>(
       gpr_realloc(rp->iovec_buf, rp->iovec_buf_length * sizeof(iovec_t)));
 }
 
-/* --- Implementation of methods defined in tsi_grpc_record_protocol_common.h.
- * --- */
+// --- Implementation of methods defined in tsi_grpc_record_protocol_common.h.
+// ---
 
 void alts_grpc_record_protocol_convert_slice_buffer_to_iovec(
     alts_grpc_record_protocol* rp, const grpc_slice_buffer* sb) {
@@ -77,8 +78,8 @@ iovec_t alts_grpc_record_protocol_get_header_iovec(
   if (rp->header_sb.count == 1) {
     header_iovec.iov_base = GRPC_SLICE_START_PTR(rp->header_sb.slices[0]);
   } else {
-    /* Frame header is in multiple slices, copies the header bytes from slice
-     * buffer to a single flat buffer.  */
+    // Frame header is in multiple slices, copies the header bytes from slice
+    // buffer to a single flat buffer.
     alts_grpc_record_protocol_copy_slice_buffer(&rp->header_sb, rp->header_buf);
     header_iovec.iov_base = rp->header_buf;
   }
@@ -95,7 +96,7 @@ tsi_result alts_grpc_record_protocol_init(alts_grpc_record_protocol* rp,
             "Invalid nullptr arguments to alts_grpc_record_protocol init.");
     return TSI_INVALID_ARGUMENT;
   }
-  /* Creates alts_iovec_record_protocol.  */
+  // Creates alts_iovec_record_protocol.
   char* error_details = nullptr;
   grpc_status_code status = alts_iovec_record_protocol_create(
       crypter, overflow_size, is_client, is_integrity_only, is_protect,
@@ -106,20 +107,20 @@ tsi_result alts_grpc_record_protocol_init(alts_grpc_record_protocol* rp,
     gpr_free(error_details);
     return TSI_INTERNAL_ERROR;
   }
-  /* Allocates header slice buffer.  */
+  // Allocates header slice buffer.
   grpc_slice_buffer_init(&rp->header_sb);
-  /* Allocates header buffer.  */
+  // Allocates header buffer.
   rp->header_length = alts_iovec_record_protocol_get_header_length();
   rp->header_buf = static_cast<unsigned char*>(gpr_malloc(rp->header_length));
   rp->tag_length = alts_iovec_record_protocol_get_tag_length(rp->iovec_rp);
-  /* Allocates iovec buffer.  */
+  // Allocates iovec buffer.
   rp->iovec_buf_length = kInitialIovecBufferSize;
   rp->iovec_buf =
       static_cast<iovec_t*>(gpr_malloc(rp->iovec_buf_length * sizeof(iovec_t)));
   return TSI_OK;
 }
 
-/* --- Implementation of methods defined in tsi_grpc_record_protocol.h. --- */
+// --- Implementation of methods defined in tsi_grpc_record_protocol.h. ---
 tsi_result alts_grpc_record_protocol_protect(
     alts_grpc_record_protocol* self, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices) {
@@ -162,8 +163,8 @@ void alts_grpc_record_protocol_destroy(alts_grpc_record_protocol* self) {
   gpr_free(self);
 }
 
-/* Integrity-only and privacy-integrity share the same implementation. No need
- * to call vtable.  */
+// Integrity-only and privacy-integrity share the same implementation. No need
+// to call vtable.
 size_t alts_grpc_record_protocol_max_unprotected_data_size(
     const alts_grpc_record_protocol* self, size_t max_protected_frame_size) {
   if (self == nullptr) {

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