OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/core/quic_utils.h" | 5 #include "net/quic/core/quic_utils.h" |
6 | 6 |
7 #include <ctype.h> | 7 #include <ctype.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <algorithm> | 10 #include <algorithm> |
(...skipping 119 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
130 // This assumes that the system is little-endian. | 130 // This assumes that the system is little-endian. |
131 memcpy(out, &lo, sizeof(lo)); | 131 memcpy(out, &lo, sizeof(lo)); |
132 memcpy(out + sizeof(lo), &hi, sizeof(hi) / 2); | 132 memcpy(out + sizeof(lo), &hi, sizeof(hi) / 2); |
133 } | 133 } |
134 | 134 |
135 #define RETURN_STRING_LITERAL(x) \ | 135 #define RETURN_STRING_LITERAL(x) \ |
136 case x: \ | 136 case x: \ |
137 return #x; | 137 return #x; |
138 | 138 |
139 // static | 139 // static |
140 const char* QuicUtils::StreamErrorToString(QuicRstStreamErrorCode error) { | |
141 switch (error) { | |
142 RETURN_STRING_LITERAL(QUIC_STREAM_NO_ERROR); | |
143 RETURN_STRING_LITERAL(QUIC_STREAM_CONNECTION_ERROR); | |
144 RETURN_STRING_LITERAL(QUIC_ERROR_PROCESSING_STREAM); | |
145 RETURN_STRING_LITERAL(QUIC_MULTIPLE_TERMINATION_OFFSETS); | |
146 RETURN_STRING_LITERAL(QUIC_BAD_APPLICATION_PAYLOAD); | |
147 RETURN_STRING_LITERAL(QUIC_STREAM_PEER_GOING_AWAY); | |
148 RETURN_STRING_LITERAL(QUIC_STREAM_CANCELLED); | |
149 RETURN_STRING_LITERAL(QUIC_RST_ACKNOWLEDGEMENT); | |
150 RETURN_STRING_LITERAL(QUIC_REFUSED_STREAM); | |
151 RETURN_STRING_LITERAL(QUIC_STREAM_LAST_ERROR); | |
152 RETURN_STRING_LITERAL(QUIC_INVALID_PROMISE_URL); | |
153 RETURN_STRING_LITERAL(QUIC_UNAUTHORIZED_PROMISE_URL); | |
154 RETURN_STRING_LITERAL(QUIC_DUPLICATE_PROMISE_URL); | |
155 RETURN_STRING_LITERAL(QUIC_PROMISE_VARY_MISMATCH); | |
156 RETURN_STRING_LITERAL(QUIC_INVALID_PROMISE_METHOD); | |
157 RETURN_STRING_LITERAL(QUIC_PUSH_STREAM_TIMED_OUT); | |
158 RETURN_STRING_LITERAL(QUIC_HEADERS_TOO_LARGE); | |
159 } | |
160 // Return a default value so that we return this when |error| doesn't match | |
161 // any of the QuicRstStreamErrorCodes. This can happen when the RstStream | |
162 // frame sent by the peer (attacker) has invalid error code. | |
163 return "INVALID_RST_STREAM_ERROR_CODE"; | |
164 } | |
165 | |
166 // static | |
167 const char* QuicUtils::ErrorToString(QuicErrorCode error) { | |
168 switch (error) { | |
169 RETURN_STRING_LITERAL(QUIC_NO_ERROR); | |
170 RETURN_STRING_LITERAL(QUIC_INTERNAL_ERROR); | |
171 RETURN_STRING_LITERAL(QUIC_STREAM_DATA_AFTER_TERMINATION); | |
172 RETURN_STRING_LITERAL(QUIC_INVALID_PACKET_HEADER); | |
173 RETURN_STRING_LITERAL(QUIC_INVALID_FRAME_DATA); | |
174 RETURN_STRING_LITERAL(QUIC_MISSING_PAYLOAD); | |
175 RETURN_STRING_LITERAL(QUIC_INVALID_FEC_DATA); | |
176 RETURN_STRING_LITERAL(QUIC_INVALID_STREAM_DATA); | |
177 RETURN_STRING_LITERAL(QUIC_OVERLAPPING_STREAM_DATA); | |
178 RETURN_STRING_LITERAL(QUIC_UNENCRYPTED_STREAM_DATA); | |
179 RETURN_STRING_LITERAL(QUIC_INVALID_RST_STREAM_DATA); | |
180 RETURN_STRING_LITERAL(QUIC_INVALID_CONNECTION_CLOSE_DATA); | |
181 RETURN_STRING_LITERAL(QUIC_INVALID_GOAWAY_DATA); | |
182 RETURN_STRING_LITERAL(QUIC_INVALID_WINDOW_UPDATE_DATA); | |
183 RETURN_STRING_LITERAL(QUIC_INVALID_BLOCKED_DATA); | |
184 RETURN_STRING_LITERAL(QUIC_INVALID_STOP_WAITING_DATA); | |
185 RETURN_STRING_LITERAL(QUIC_INVALID_PATH_CLOSE_DATA); | |
186 RETURN_STRING_LITERAL(QUIC_INVALID_ACK_DATA); | |
187 RETURN_STRING_LITERAL(QUIC_INVALID_VERSION_NEGOTIATION_PACKET); | |
188 RETURN_STRING_LITERAL(QUIC_INVALID_PUBLIC_RST_PACKET); | |
189 RETURN_STRING_LITERAL(QUIC_DECRYPTION_FAILURE); | |
190 RETURN_STRING_LITERAL(QUIC_ENCRYPTION_FAILURE); | |
191 RETURN_STRING_LITERAL(QUIC_PACKET_TOO_LARGE); | |
192 RETURN_STRING_LITERAL(QUIC_PEER_GOING_AWAY); | |
193 RETURN_STRING_LITERAL(QUIC_HANDSHAKE_FAILED); | |
194 RETURN_STRING_LITERAL(QUIC_CRYPTO_TAGS_OUT_OF_ORDER); | |
195 RETURN_STRING_LITERAL(QUIC_CRYPTO_TOO_MANY_ENTRIES); | |
196 RETURN_STRING_LITERAL(QUIC_CRYPTO_TOO_MANY_REJECTS); | |
197 RETURN_STRING_LITERAL(QUIC_CRYPTO_INVALID_VALUE_LENGTH) | |
198 RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE); | |
199 RETURN_STRING_LITERAL(QUIC_CRYPTO_INTERNAL_ERROR); | |
200 RETURN_STRING_LITERAL(QUIC_CRYPTO_VERSION_NOT_SUPPORTED); | |
201 RETURN_STRING_LITERAL(QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT); | |
202 RETURN_STRING_LITERAL(QUIC_CRYPTO_NO_SUPPORT); | |
203 RETURN_STRING_LITERAL(QUIC_INVALID_CRYPTO_MESSAGE_TYPE); | |
204 RETURN_STRING_LITERAL(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER); | |
205 RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND); | |
206 RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP); | |
207 RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_INDEX_NOT_FOUND); | |
208 RETURN_STRING_LITERAL(QUIC_UNSUPPORTED_PROOF_DEMAND); | |
209 RETURN_STRING_LITERAL(QUIC_INVALID_STREAM_ID); | |
210 RETURN_STRING_LITERAL(QUIC_INVALID_PRIORITY); | |
211 RETURN_STRING_LITERAL(QUIC_TOO_MANY_OPEN_STREAMS); | |
212 RETURN_STRING_LITERAL(QUIC_PUBLIC_RESET); | |
213 RETURN_STRING_LITERAL(QUIC_INVALID_VERSION); | |
214 RETURN_STRING_LITERAL(QUIC_INVALID_HEADER_ID); | |
215 RETURN_STRING_LITERAL(QUIC_INVALID_NEGOTIATED_VALUE); | |
216 RETURN_STRING_LITERAL(QUIC_DECOMPRESSION_FAILURE); | |
217 RETURN_STRING_LITERAL(QUIC_NETWORK_IDLE_TIMEOUT); | |
218 RETURN_STRING_LITERAL(QUIC_HANDSHAKE_TIMEOUT); | |
219 RETURN_STRING_LITERAL(QUIC_ERROR_MIGRATING_ADDRESS); | |
220 RETURN_STRING_LITERAL(QUIC_ERROR_MIGRATING_PORT); | |
221 RETURN_STRING_LITERAL(QUIC_PACKET_WRITE_ERROR); | |
222 RETURN_STRING_LITERAL(QUIC_PACKET_READ_ERROR); | |
223 RETURN_STRING_LITERAL(QUIC_EMPTY_STREAM_FRAME_NO_FIN); | |
224 RETURN_STRING_LITERAL(QUIC_INVALID_HEADERS_STREAM_DATA); | |
225 RETURN_STRING_LITERAL(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA); | |
226 RETURN_STRING_LITERAL(QUIC_FLOW_CONTROL_SENT_TOO_MUCH_DATA); | |
227 RETURN_STRING_LITERAL(QUIC_FLOW_CONTROL_INVALID_WINDOW); | |
228 RETURN_STRING_LITERAL(QUIC_CONNECTION_IP_POOLED); | |
229 RETURN_STRING_LITERAL(QUIC_PROOF_INVALID); | |
230 RETURN_STRING_LITERAL(QUIC_CRYPTO_DUPLICATE_TAG); | |
231 RETURN_STRING_LITERAL(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT); | |
232 RETURN_STRING_LITERAL(QUIC_CRYPTO_SERVER_CONFIG_EXPIRED); | |
233 RETURN_STRING_LITERAL(QUIC_INVALID_CHANNEL_ID_SIGNATURE); | |
234 RETURN_STRING_LITERAL(QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED); | |
235 RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO); | |
236 RETURN_STRING_LITERAL(QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE); | |
237 RETURN_STRING_LITERAL(QUIC_VERSION_NEGOTIATION_MISMATCH); | |
238 RETURN_STRING_LITERAL(QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS); | |
239 RETURN_STRING_LITERAL(QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS); | |
240 RETURN_STRING_LITERAL(QUIC_CONNECTION_CANCELLED); | |
241 RETURN_STRING_LITERAL(QUIC_BAD_PACKET_LOSS_RATE); | |
242 RETURN_STRING_LITERAL(QUIC_PUBLIC_RESETS_POST_HANDSHAKE); | |
243 RETURN_STRING_LITERAL(QUIC_TIMEOUTS_WITH_OPEN_STREAMS); | |
244 RETURN_STRING_LITERAL(QUIC_FAILED_TO_SERIALIZE_PACKET); | |
245 RETURN_STRING_LITERAL(QUIC_TOO_MANY_AVAILABLE_STREAMS); | |
246 RETURN_STRING_LITERAL(QUIC_UNENCRYPTED_FEC_DATA); | |
247 RETURN_STRING_LITERAL(QUIC_BAD_MULTIPATH_FLAG); | |
248 RETURN_STRING_LITERAL(QUIC_IP_ADDRESS_CHANGED); | |
249 RETURN_STRING_LITERAL(QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS); | |
250 RETURN_STRING_LITERAL(QUIC_CONNECTION_MIGRATION_TOO_MANY_CHANGES); | |
251 RETURN_STRING_LITERAL(QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK); | |
252 RETURN_STRING_LITERAL(QUIC_CONNECTION_MIGRATION_NON_MIGRATABLE_STREAM); | |
253 RETURN_STRING_LITERAL(QUIC_TOO_MANY_RTOS); | |
254 RETURN_STRING_LITERAL(QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA); | |
255 RETURN_STRING_LITERAL(QUIC_MAYBE_CORRUPTED_MEMORY); | |
256 RETURN_STRING_LITERAL(QUIC_CRYPTO_CHLO_TOO_LARGE); | |
257 RETURN_STRING_LITERAL(QUIC_MULTIPATH_PATH_DOES_NOT_EXIST); | |
258 RETURN_STRING_LITERAL(QUIC_MULTIPATH_PATH_NOT_ACTIVE); | |
259 RETURN_STRING_LITERAL(QUIC_TOO_MANY_FRAME_GAPS); | |
260 RETURN_STRING_LITERAL(QUIC_STREAM_SEQUENCER_INVALID_STATE); | |
261 RETURN_STRING_LITERAL(QUIC_TOO_MANY_SESSIONS_ON_SERVER); | |
262 RETURN_STRING_LITERAL(QUIC_LAST_ERROR); | |
263 // Intentionally have no default case, so we'll break the build | |
264 // if we add errors and don't put them here. | |
265 } | |
266 // Return a default value so that we return this when |error| doesn't match | |
267 // any of the QuicErrorCodes. This can happen when the ConnectionClose | |
268 // frame sent by the peer (attacker) has invalid error code. | |
269 return "INVALID_ERROR_CODE"; | |
270 } | |
271 | |
272 // static | |
273 const char* QuicUtils::EncryptionLevelToString(EncryptionLevel level) { | 140 const char* QuicUtils::EncryptionLevelToString(EncryptionLevel level) { |
274 switch (level) { | 141 switch (level) { |
275 RETURN_STRING_LITERAL(ENCRYPTION_NONE); | 142 RETURN_STRING_LITERAL(ENCRYPTION_NONE); |
276 RETURN_STRING_LITERAL(ENCRYPTION_INITIAL); | 143 RETURN_STRING_LITERAL(ENCRYPTION_INITIAL); |
277 RETURN_STRING_LITERAL(ENCRYPTION_FORWARD_SECURE); | 144 RETURN_STRING_LITERAL(ENCRYPTION_FORWARD_SECURE); |
278 RETURN_STRING_LITERAL(NUM_ENCRYPTION_LEVELS); | 145 RETURN_STRING_LITERAL(NUM_ENCRYPTION_LEVELS); |
279 } | 146 } |
280 return "INVALID_ENCRYPTION_LEVEL"; | 147 return "INVALID_ENCRYPTION_LEVEL"; |
281 } | 148 } |
282 | 149 |
(...skipping 210 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
493 | 360 |
494 bytes_remaining -= line_bytes; | 361 bytes_remaining -= line_bytes; |
495 offset += line_bytes; | 362 offset += line_bytes; |
496 p += line_bytes; | 363 p += line_bytes; |
497 s += '\n'; | 364 s += '\n'; |
498 } | 365 } |
499 return s; | 366 return s; |
500 } | 367 } |
501 | 368 |
502 } // namespace net | 369 } // namespace net |
OLD | NEW |