grpc 1.50.0.pre1 → 1.52.0.pre2

data/src/core/tsi/transport_security.h

@@ -1,20 +1,20 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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.
+//
+//
 
 #ifndef GRPC_CORE_TSI_TRANSPORT_SECURITY_H
 #define GRPC_CORE_TSI_TRANSPORT_SECURITY_H
@@ -28,9 +28,9 @@
 
 extern grpc_core::TraceFlag tsi_tracing_enabled;
 
-/* Base for tsi_frame_protector implementations.
-   See transport_security_interface.h for documentation.
-   All methods must be implemented. */
+// Base for tsi_frame_protector implementations.
+// See transport_security_interface.h for documentation.
+// All methods must be implemented.
 struct tsi_frame_protector_vtable {
   tsi_result (*protect)(tsi_frame_protector* self,
                         const unsigned char* unprotected_bytes,
@@ -52,12 +52,12 @@ struct tsi_frame_protector {
   const tsi_frame_protector_vtable* vtable;
 };
 
-/* Base for tsi_handshaker implementations.
-   See transport_security_interface.h for documentation. */
+// Base for tsi_handshaker implementations.
+// See transport_security_interface.h for documentation.
 struct tsi_handshaker_vtable {
-  /* Methods for supporting the old synchronous API.
-     These can be null if the TSI impl supports only the new
-     async-capable API. */
+  // Methods for supporting the old synchronous API.
+  // These can be null if the TSI impl supports only the new
+  // async-capable API.
   tsi_result (*get_bytes_to_send_to_peer)(tsi_handshaker* self,
                                           unsigned char* bytes,
                                           size_t* bytes_size);
@@ -69,10 +69,10 @@ struct tsi_handshaker_vtable {
   tsi_result (*create_frame_protector)(tsi_handshaker* self,
                                        size_t* max_protected_frame_size,
                                        tsi_frame_protector** protector);
-  /* Must be implemented by all TSI impls. */
+  // Must be implemented by all TSI impls.
   void (*destroy)(tsi_handshaker* self);
-  /* Methods for supporting the new async-capable API.
-     These can be null if the TSI impl supports only the old sync API. */
+  // Methods for supporting the new async-capable API.
+  // These can be null if the TSI impl supports only the old sync API.
   tsi_result (*next)(tsi_handshaker* self, const unsigned char* received_bytes,
                      size_t received_bytes_size,
                      const unsigned char** bytes_to_send,
@@ -89,28 +89,28 @@ struct tsi_handshaker {
   bool handshake_shutdown;
 };
 
-/* Base for tsi_handshaker_result implementations.
-   See transport_security_interface.h for documentation.
-   The exec_ctx parameter in create_zero_copy_grpc_protector is supposed to be
-   of type grpc_exec_ctx*, but we're using void* instead to avoid making the TSI
-   API depend on grpc. The create_zero_copy_grpc_protector() method is only used
-   in grpc, where we do need the exec_ctx passed through, but the API still
-   needs to compile in other applications, where grpc_exec_ctx is not defined.
-   All methods must be non-null, except where noted below.
-*/
+// Base for tsi_handshaker_result implementations.
+// See transport_security_interface.h for documentation.
+// The exec_ctx parameter in create_zero_copy_grpc_protector is supposed to be
+// of type grpc_exec_ctx*, but we're using void* instead to avoid making the TSI
+// API depend on grpc. The create_zero_copy_grpc_protector() method is only used
+// in grpc, where we do need the exec_ctx passed through, but the API still
+// needs to compile in other applications, where grpc_exec_ctx is not defined.
+// All methods must be non-null, except where noted below.
+//
 struct tsi_handshaker_result_vtable {
   tsi_result (*extract_peer)(const tsi_handshaker_result* self, tsi_peer* peer);
   tsi_result (*get_frame_protector_type)(
       const tsi_handshaker_result* self,
       tsi_frame_protector_type* frame_protector_type);
-  /* May be null if get_frame_protector_type() returns
-     TSI_FRAME_PROTECTOR_NORMAL or TSI_FRAME_PROTECTOR_NONE. */
+  // May be null if get_frame_protector_type() returns
+  // TSI_FRAME_PROTECTOR_NORMAL or TSI_FRAME_PROTECTOR_NONE.
   tsi_result (*create_zero_copy_grpc_protector)(
       const tsi_handshaker_result* self,
       size_t* max_output_protected_frame_size,
       tsi_zero_copy_grpc_protector** protector);
-  /* May be null if get_frame_protector_type() returns
-     TSI_FRAME_PROTECTOR_ZERO_COPY or TSI_FRAME_PROTECTOR_NONE. */
+  // May be null if get_frame_protector_type() returns
+  // TSI_FRAME_PROTECTOR_ZERO_COPY or TSI_FRAME_PROTECTOR_NONE.
   tsi_result (*create_frame_protector)(const tsi_handshaker_result* self,
                                        size_t* max_output_protected_frame_size,
                                        tsi_frame_protector** protector);
@@ -123,7 +123,7 @@ struct tsi_handshaker_result {
   const tsi_handshaker_result_vtable* vtable;
 };
 
-/* Peer and property construction/destruction functions. */
+// Peer and property construction/destruction functions.
 tsi_result tsi_construct_peer(size_t property_count, tsi_peer* peer);
 tsi_peer_property tsi_init_peer_property(void);
 void tsi_peer_property_destruct(tsi_peer_property* property);
@@ -137,7 +137,7 @@ tsi_result tsi_construct_string_peer_property_from_cstring(
     const char* name, const char* value, tsi_peer_property* property);
 const tsi_peer_property* tsi_peer_get_property_by_name(const tsi_peer* peer,
                                                        const char* name);
-/* Utils. */
-char* tsi_strdup(const char* src); /* Sadly, no strdup in C89. */
+// Utils.
+char* tsi_strdup(const char* src);  // Sadly, no strdup in C89.
 
-#endif /* GRPC_CORE_TSI_TRANSPORT_SECURITY_H */
+#endif  // GRPC_CORE_TSI_TRANSPORT_SECURITY_H

data/src/core/tsi/transport_security_grpc.cc

@@ -1,26 +1,26 @@
-/*
- *
- * Copyright 2017 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 2017 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>
 
 #include "src/core/tsi/transport_security_grpc.h"
 
-/* This method creates a tsi_zero_copy_grpc_protector object.  */
+// This method creates a tsi_zero_copy_grpc_protector object.
 tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
     const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
     tsi_zero_copy_grpc_protector** protector) {
@@ -34,9 +34,9 @@ tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
       self, max_output_protected_frame_size, protector);
 }
 
-/* --- tsi_zero_copy_grpc_protector common implementation. ---
+// --- tsi_zero_copy_grpc_protector common implementation. ---
 
-   Calls specific implementation after state/input validation. */
+// Calls specific implementation after state/input validation.
 
 tsi_result tsi_zero_copy_grpc_protector_protect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* unprotected_slices,

data/src/core/tsi/transport_security_grpc.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 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 2017 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_TRANSPORT_SECURITY_GRPC_H
 #define GRPC_CORE_TSI_TRANSPORT_SECURITY_GRPC_H
@@ -25,45 +25,45 @@
 
 #include "src/core/tsi/transport_security.h"
 
-/* This method creates a tsi_zero_copy_grpc_protector object. It return TSI_OK
-   assuming there is no fatal error.
-   The caller is responsible for destroying the protector.  */
+// This method creates a tsi_zero_copy_grpc_protector object. It return TSI_OK
+// assuming there is no fatal error.
+// The caller is responsible for destroying the protector.
 tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
     const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
     tsi_zero_copy_grpc_protector** protector);
 
-/* -- tsi_zero_copy_grpc_protector object --  */
+// -- tsi_zero_copy_grpc_protector object --
 
-/* Outputs protected frames.
-   - unprotected_slices is the unprotected data to be protected.
-   - protected_slices is the protected output frames. One or more frames
-     may be produced in this protect function.
-   - This method returns TSI_OK in case of success or a specific error code in
-     case of failure.  */
+// Outputs protected frames.
+// - unprotected_slices is the unprotected data to be protected.
+// - protected_slices is the protected output frames. One or more frames
+//   may be produced in this protect function.
+// - This method returns TSI_OK in case of success or a specific error code in
+//   case of failure.
 tsi_result tsi_zero_copy_grpc_protector_protect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices);
 
-/* Outputs unprotected bytes.
-   - protected_slices is the bytes of protected frames.
-   - unprotected_slices is the unprotected output data.
-   - if min_progress_size is not null, it returns the size of the last
-     incomplete frame which could not be fully unprotected.
-   - This method returns TSI_OK in case of success. Success includes cases where
-     there is not enough data to output in which case unprotected_slices has 0
-     bytes.  */
+// Outputs unprotected bytes.
+// - protected_slices is the bytes of protected frames.
+// - unprotected_slices is the unprotected output data.
+// - if min_progress_size is not null, it returns the size of the last
+//   incomplete frame which could not be fully unprotected.
+// - This method returns TSI_OK in case of success. Success includes cases where
+//   there is not enough data to output in which case unprotected_slices has 0
+//   bytes.
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
     grpc_slice_buffer* unprotected_slices, int* min_progress_size);
 
-/* Destroys the tsi_zero_copy_grpc_protector object.  */
+// Destroys the tsi_zero_copy_grpc_protector object.
 void tsi_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector* self);
 
-/* Returns value of max protected frame size. Useful for testing. */
+// Returns value of max protected frame size. Useful for testing.
 tsi_result tsi_zero_copy_grpc_protector_max_frame_size(
     tsi_zero_copy_grpc_protector* self, size_t* max_frame_size);
 
-/* Base for tsi_zero_copy_grpc_protector implementations.  */
+// Base for tsi_zero_copy_grpc_protector implementations.
 struct tsi_zero_copy_grpc_protector_vtable {
   tsi_result (*protect)(tsi_zero_copy_grpc_protector* self,
                         grpc_slice_buffer* unprotected_slices,
@@ -80,4 +80,4 @@ struct tsi_zero_copy_grpc_protector {
   const tsi_zero_copy_grpc_protector_vtable* vtable;
 };
 
-#endif /* GRPC_CORE_TSI_TRANSPORT_SECURITY_GRPC_H */
+#endif  // GRPC_CORE_TSI_TRANSPORT_SECURITY_GRPC_H