Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 3 | * Copyright 2015 gRPC authors. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 4 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 8 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 10 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 16 | * |
| 17 | */ |
| 18 | |
Craig Tiller | b29f1fe | 2017-03-28 15:49:23 -0700 | [diff] [blame] | 19 | #include "src/core/tsi/transport_security.h" |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 20 | |
Nicolas "Pixel" Noble | b29d8cf | 2016-04-08 01:38:29 +0200 | [diff] [blame] | 21 | #include <grpc/support/alloc.h> |
| 22 | #include <grpc/support/string_util.h> |
| 23 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 24 | #include <stdlib.h> |
| 25 | #include <string.h> |
| 26 | |
Julien Boeuf | 980f600 | 2015-02-26 16:41:41 -0800 | [diff] [blame] | 27 | /* --- Tracing. --- */ |
| 28 | |
ncteisen | 06bce6e | 2017-07-10 07:58:49 -0700 | [diff] [blame] | 29 | grpc_tracer_flag tsi_tracing_enabled = GRPC_TRACER_INITIALIZER(false, "tsi"); |
Julien Boeuf | 980f600 | 2015-02-26 16:41:41 -0800 | [diff] [blame] | 30 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 31 | /* --- tsi_result common implementation. --- */ |
| 32 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 33 | const char* tsi_result_to_string(tsi_result result) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 34 | switch (result) { |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 35 | case TSI_OK: |
| 36 | return "TSI_OK"; |
| 37 | case TSI_UNKNOWN_ERROR: |
| 38 | return "TSI_UNKNOWN_ERROR"; |
| 39 | case TSI_INVALID_ARGUMENT: |
| 40 | return "TSI_INVALID_ARGUMENT"; |
| 41 | case TSI_PERMISSION_DENIED: |
| 42 | return "TSI_PERMISSION_DENIED"; |
| 43 | case TSI_INCOMPLETE_DATA: |
| 44 | return "TSI_INCOMPLETE_DATA"; |
| 45 | case TSI_FAILED_PRECONDITION: |
| 46 | return "TSI_FAILED_PRECONDITION"; |
| 47 | case TSI_UNIMPLEMENTED: |
| 48 | return "TSI_UNIMPLEMENTED"; |
| 49 | case TSI_INTERNAL_ERROR: |
| 50 | return "TSI_INTERNAL_ERROR"; |
| 51 | case TSI_DATA_CORRUPTED: |
| 52 | return "TSI_DATA_CORRUPTED"; |
| 53 | case TSI_NOT_FOUND: |
| 54 | return "TSI_NOT_FOUND"; |
| 55 | case TSI_PROTOCOL_FAILURE: |
| 56 | return "TSI_PROTOCOL_FAILURE"; |
| 57 | case TSI_HANDSHAKE_IN_PROGRESS: |
| 58 | return "TSI_HANDSHAKE_IN_PROGRESS"; |
| 59 | case TSI_OUT_OF_RESOURCES: |
| 60 | return "TSI_OUT_OF_RESOURCES"; |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 61 | case TSI_ASYNC: |
| 62 | return "TSI_ASYNC"; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 63 | default: |
| 64 | return "UNKNOWN"; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 65 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 66 | } |
| 67 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 68 | /* --- tsi_frame_protector common implementation. --- |
| 69 | |
| 70 | Calls specific implementation after state/input validation. */ |
| 71 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 72 | tsi_result tsi_frame_protector_protect(tsi_frame_protector* self, |
| 73 | const unsigned char* unprotected_bytes, |
| 74 | size_t* unprotected_bytes_size, |
| 75 | unsigned char* protected_output_frames, |
| 76 | size_t* protected_output_frames_size) { |
Craig Tiller | be98d24 | 2017-11-10 15:26:57 -0800 | [diff] [blame] | 77 | if (self == nullptr || self->vtable == nullptr || |
| 78 | unprotected_bytes == nullptr || unprotected_bytes_size == nullptr || |
| 79 | protected_output_frames == nullptr || |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 80 | protected_output_frames_size == nullptr) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 81 | return TSI_INVALID_ARGUMENT; |
| 82 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 83 | if (self->vtable->protect == nullptr) return TSI_UNIMPLEMENTED; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 84 | return self->vtable->protect(self, unprotected_bytes, unprotected_bytes_size, |
| 85 | protected_output_frames, |
| 86 | protected_output_frames_size); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 87 | } |
| 88 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 89 | tsi_result tsi_frame_protector_protect_flush( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 90 | tsi_frame_protector* self, unsigned char* protected_output_frames, |
| 91 | size_t* protected_output_frames_size, size_t* still_pending_size) { |
Craig Tiller | be98d24 | 2017-11-10 15:26:57 -0800 | [diff] [blame] | 92 | if (self == nullptr || self->vtable == nullptr || |
| 93 | protected_output_frames == nullptr || |
| 94 | protected_output_frames_size == nullptr || |
| 95 | still_pending_size == nullptr) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 96 | return TSI_INVALID_ARGUMENT; |
| 97 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 98 | if (self->vtable->protect_flush == nullptr) return TSI_UNIMPLEMENTED; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 99 | return self->vtable->protect_flush(self, protected_output_frames, |
| 100 | protected_output_frames_size, |
| 101 | still_pending_size); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 102 | } |
| 103 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 104 | tsi_result tsi_frame_protector_unprotect( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 105 | tsi_frame_protector* self, const unsigned char* protected_frames_bytes, |
| 106 | size_t* protected_frames_bytes_size, unsigned char* unprotected_bytes, |
| 107 | size_t* unprotected_bytes_size) { |
Craig Tiller | be98d24 | 2017-11-10 15:26:57 -0800 | [diff] [blame] | 108 | if (self == nullptr || self->vtable == nullptr || |
| 109 | protected_frames_bytes == nullptr || |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 110 | protected_frames_bytes_size == nullptr || unprotected_bytes == nullptr || |
| 111 | unprotected_bytes_size == nullptr) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 112 | return TSI_INVALID_ARGUMENT; |
| 113 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 114 | if (self->vtable->unprotect == nullptr) return TSI_UNIMPLEMENTED; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 115 | return self->vtable->unprotect(self, protected_frames_bytes, |
| 116 | protected_frames_bytes_size, unprotected_bytes, |
| 117 | unprotected_bytes_size); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 118 | } |
| 119 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 120 | void tsi_frame_protector_destroy(tsi_frame_protector* self) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 121 | if (self == nullptr) return; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 122 | self->vtable->destroy(self); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 123 | } |
| 124 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 125 | /* --- tsi_handshaker common implementation. --- |
| 126 | |
| 127 | Calls specific implementation after state/input validation. */ |
| 128 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 129 | tsi_result tsi_handshaker_get_bytes_to_send_to_peer(tsi_handshaker* self, |
| 130 | unsigned char* bytes, |
| 131 | size_t* bytes_size) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 132 | if (self == nullptr || self->vtable == nullptr || bytes == nullptr || |
| 133 | bytes_size == nullptr) { |
Julien Boeuf | 4c8e818 | 2015-12-07 11:34:12 -0800 | [diff] [blame] | 134 | return TSI_INVALID_ARGUMENT; |
| 135 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 136 | if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
Craig Tiller | be98d24 | 2017-11-10 15:26:57 -0800 | [diff] [blame] | 137 | if (self->vtable->get_bytes_to_send_to_peer == nullptr) |
| 138 | return TSI_UNIMPLEMENTED; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 139 | return self->vtable->get_bytes_to_send_to_peer(self, bytes, bytes_size); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 140 | } |
| 141 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 142 | tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker* self, |
| 143 | const unsigned char* bytes, |
| 144 | size_t* bytes_size) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 145 | if (self == nullptr || self->vtable == nullptr || bytes == nullptr || |
| 146 | bytes_size == nullptr) { |
Julien Boeuf | 4c8e818 | 2015-12-07 11:34:12 -0800 | [diff] [blame] | 147 | return TSI_INVALID_ARGUMENT; |
| 148 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 149 | if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
Craig Tiller | be98d24 | 2017-11-10 15:26:57 -0800 | [diff] [blame] | 150 | if (self->vtable->process_bytes_from_peer == nullptr) |
| 151 | return TSI_UNIMPLEMENTED; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 152 | return self->vtable->process_bytes_from_peer(self, bytes, bytes_size); |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 153 | } |
| 154 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 155 | tsi_result tsi_handshaker_get_result(tsi_handshaker* self) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 156 | if (self == nullptr || self->vtable == nullptr) return TSI_INVALID_ARGUMENT; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 157 | if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 158 | if (self->vtable->get_result == nullptr) return TSI_UNIMPLEMENTED; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 159 | return self->vtable->get_result(self); |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 160 | } |
| 161 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 162 | tsi_result tsi_handshaker_extract_peer(tsi_handshaker* self, tsi_peer* peer) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 163 | if (self == nullptr || self->vtable == nullptr || peer == nullptr) { |
Jiangtao Li | 0211cfb | 2017-08-07 11:24:07 -0700 | [diff] [blame] | 164 | return TSI_INVALID_ARGUMENT; |
| 165 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 166 | memset(peer, 0, sizeof(tsi_peer)); |
| 167 | if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
| 168 | if (tsi_handshaker_get_result(self) != TSI_OK) { |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 169 | return TSI_FAILED_PRECONDITION; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 170 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 171 | if (self->vtable->extract_peer == nullptr) return TSI_UNIMPLEMENTED; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 172 | return self->vtable->extract_peer(self, peer); |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 173 | } |
| 174 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 175 | tsi_result tsi_handshaker_create_frame_protector( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 176 | tsi_handshaker* self, size_t* max_protected_frame_size, |
| 177 | tsi_frame_protector** protector) { |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 178 | tsi_result result; |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 179 | if (self == nullptr || self->vtable == nullptr || protector == nullptr) { |
Jiangtao Li | 0211cfb | 2017-08-07 11:24:07 -0700 | [diff] [blame] | 180 | return TSI_INVALID_ARGUMENT; |
| 181 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 182 | if (self->frame_protector_created) return TSI_FAILED_PRECONDITION; |
Jiangtao Li | 0211cfb | 2017-08-07 11:24:07 -0700 | [diff] [blame] | 183 | if (tsi_handshaker_get_result(self) != TSI_OK) return TSI_FAILED_PRECONDITION; |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 184 | if (self->vtable->create_frame_protector == nullptr) return TSI_UNIMPLEMENTED; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 185 | result = self->vtable->create_frame_protector(self, max_protected_frame_size, |
| 186 | protector); |
| 187 | if (result == TSI_OK) { |
jiangtaoli2016 | e69881d | 2017-04-10 14:29:43 -0700 | [diff] [blame] | 188 | self->frame_protector_created = true; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 189 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 190 | return result; |
| 191 | } |
| 192 | |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 193 | tsi_result tsi_handshaker_next( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 194 | tsi_handshaker* self, const unsigned char* received_bytes, |
| 195 | size_t received_bytes_size, const unsigned char** bytes_to_send, |
| 196 | size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result, |
| 197 | tsi_handshaker_on_next_done_cb cb, void* user_data) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 198 | if (self == nullptr || self->vtable == nullptr) return TSI_INVALID_ARGUMENT; |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 199 | if (self->handshaker_result_created) return TSI_FAILED_PRECONDITION; |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 200 | if (self->vtable->next == nullptr) return TSI_UNIMPLEMENTED; |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 201 | return self->vtable->next(self, received_bytes, received_bytes_size, |
| 202 | bytes_to_send, bytes_to_send_size, |
| 203 | handshaker_result, cb, user_data); |
| 204 | } |
| 205 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 206 | void tsi_handshaker_destroy(tsi_handshaker* self) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 207 | if (self == nullptr) return; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 208 | self->vtable->destroy(self); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 209 | } |
| 210 | |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 211 | /* --- tsi_handshaker_result implementation. --- */ |
| 212 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 213 | tsi_result tsi_handshaker_result_extract_peer(const tsi_handshaker_result* self, |
| 214 | tsi_peer* peer) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 215 | if (self == nullptr || self->vtable == nullptr || peer == nullptr) { |
Jiangtao Li | 0211cfb | 2017-08-07 11:24:07 -0700 | [diff] [blame] | 216 | return TSI_INVALID_ARGUMENT; |
Jiangtao Li | f5504a3 | 2017-08-07 10:48:46 -0700 | [diff] [blame] | 217 | } |
Jiangtao Li | 0211cfb | 2017-08-07 11:24:07 -0700 | [diff] [blame] | 218 | memset(peer, 0, sizeof(tsi_peer)); |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 219 | if (self->vtable->extract_peer == nullptr) return TSI_UNIMPLEMENTED; |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 220 | return self->vtable->extract_peer(self, peer); |
| 221 | } |
| 222 | |
| 223 | tsi_result tsi_handshaker_result_create_frame_protector( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 224 | const tsi_handshaker_result* self, size_t* max_protected_frame_size, |
| 225 | tsi_frame_protector** protector) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 226 | if (self == nullptr || self->vtable == nullptr || protector == nullptr) { |
Jiangtao Li | 0211cfb | 2017-08-07 11:24:07 -0700 | [diff] [blame] | 227 | return TSI_INVALID_ARGUMENT; |
jiangtaoli2016 | c195502 | 2017-04-11 09:36:19 -0700 | [diff] [blame] | 228 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 229 | if (self->vtable->create_frame_protector == nullptr) return TSI_UNIMPLEMENTED; |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 230 | return self->vtable->create_frame_protector(self, max_protected_frame_size, |
| 231 | protector); |
| 232 | } |
| 233 | |
| 234 | tsi_result tsi_handshaker_result_get_unused_bytes( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 235 | const tsi_handshaker_result* self, const unsigned char** bytes, |
| 236 | size_t* bytes_size) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 237 | if (self == nullptr || self->vtable == nullptr || bytes == nullptr || |
| 238 | bytes_size == nullptr) { |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 239 | return TSI_INVALID_ARGUMENT; |
| 240 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 241 | if (self->vtable->get_unused_bytes == nullptr) return TSI_UNIMPLEMENTED; |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 242 | return self->vtable->get_unused_bytes(self, bytes, bytes_size); |
| 243 | } |
| 244 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 245 | void tsi_handshaker_result_destroy(tsi_handshaker_result* self) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 246 | if (self == nullptr) return; |
jiangtaoli2016 | 20b9f94 | 2017-04-07 12:50:33 -0700 | [diff] [blame] | 247 | self->vtable->destroy(self); |
| 248 | } |
| 249 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 250 | /* --- tsi_peer implementation. --- */ |
| 251 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 252 | tsi_peer_property tsi_init_peer_property(void) { |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 253 | tsi_peer_property property; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 254 | memset(&property, 0, sizeof(tsi_peer_property)); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 255 | return property; |
| 256 | } |
| 257 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 258 | static void tsi_peer_destroy_list_property(tsi_peer_property* children, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 259 | size_t child_count) { |
Julien Boeuf | b222b4d | 2015-01-15 17:01:39 -0800 | [diff] [blame] | 260 | size_t i; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 261 | for (i = 0; i < child_count; i++) { |
| 262 | tsi_peer_property_destruct(&children[i]); |
| 263 | } |
Nicolas "Pixel" Noble | b29d8cf | 2016-04-08 01:38:29 +0200 | [diff] [blame] | 264 | gpr_free(children); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 265 | } |
| 266 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 267 | void tsi_peer_property_destruct(tsi_peer_property* property) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 268 | if (property->name != nullptr) { |
Nicolas "Pixel" Noble | b29d8cf | 2016-04-08 01:38:29 +0200 | [diff] [blame] | 269 | gpr_free(property->name); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 270 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 271 | if (property->value.data != nullptr) { |
Nicolas "Pixel" Noble | b29d8cf | 2016-04-08 01:38:29 +0200 | [diff] [blame] | 272 | gpr_free(property->value.data); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 273 | } |
| 274 | *property = tsi_init_peer_property(); /* Reset everything to 0. */ |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 275 | } |
| 276 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 277 | void tsi_peer_destruct(tsi_peer* self) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 278 | if (self == nullptr) return; |
| 279 | if (self->properties != nullptr) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 280 | tsi_peer_destroy_list_property(self->properties, self->property_count); |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 281 | self->properties = nullptr; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 282 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 283 | self->property_count = 0; |
| 284 | } |
| 285 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 286 | tsi_result tsi_construct_allocated_string_peer_property( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 287 | const char* name, size_t value_length, tsi_peer_property* property) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 288 | *property = tsi_init_peer_property(); |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 289 | if (name != nullptr) property->name = gpr_strdup(name); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 290 | if (value_length > 0) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 291 | property->value.data = (char*)gpr_zalloc(value_length); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 292 | property->value.length = value_length; |
| 293 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 294 | return TSI_OK; |
| 295 | } |
| 296 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 297 | tsi_result tsi_construct_string_peer_property_from_cstring( |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 298 | const char* name, const char* value, tsi_peer_property* property) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 299 | return tsi_construct_string_peer_property(name, value, strlen(value), |
| 300 | property); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 301 | } |
| 302 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 303 | tsi_result tsi_construct_string_peer_property(const char* name, |
| 304 | const char* value, |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 305 | size_t value_length, |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 306 | tsi_peer_property* property) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 307 | tsi_result result = tsi_construct_allocated_string_peer_property( |
| 308 | name, value_length, property); |
| 309 | if (result != TSI_OK) return result; |
| 310 | if (value_length > 0) { |
| 311 | memcpy(property->value.data, value, value_length); |
| 312 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 313 | return TSI_OK; |
| 314 | } |
| 315 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 316 | tsi_result tsi_construct_peer(size_t property_count, tsi_peer* peer) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 317 | memset(peer, 0, sizeof(tsi_peer)); |
| 318 | if (property_count > 0) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 319 | peer->properties = (tsi_peer_property*)gpr_zalloc( |
Yash Tibrewal | acd46e5 | 2017-09-20 11:28:25 -0700 | [diff] [blame] | 320 | property_count * sizeof(tsi_peer_property)); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 321 | peer->property_count = property_count; |
| 322 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 323 | return TSI_OK; |
Craig Tiller | 190d360 | 2015-02-18 09:23:38 -0800 | [diff] [blame] | 324 | } |