Pass BoringSSL error messages from C++ IO threads back into to Dart.

runtime/bin/secure_socket.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/secure_socket.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <stdio.h>
@@ skipping 27 matching lines @@
 
 static const int kSSLFilterNativeFieldIndex = 0;
 static const int kSecurityContextNativeFieldIndex = 0;
 static const int kX509NativeFieldIndex = 0;
 
 static const bool SSL_LOG_STATUS = false;
 static const bool SSL_LOG_DATA = false;
 
 static const int SSL_ERROR_MESSAGE_BUFFER_SIZE = 1000;
 
+
+/* Get the error messages from BoringSSL, and put them in buffer as a
+ * null-terminated string. */
+static void FetchErrorString(char* buffer, int length) {
+  buffer[0] = '\0';
+  int error = ERR_get_error();
+  while (error != 0) {
+    int used = strlen(buffer);
+    int free_length = length - used;
+    if (free_length > 16) {
+      // Enough room for error code at least.
+      if (used > 0) {
+        buffer[used] = '\n';
+        buffer[used + 1] = '\0';
+        used++;
+        free_length--;
+      }
+      ERR_error_string_n(error, buffer + used, free_length);
+      // ERR_error_string_n is guaranteed to leave a null-terminated string.
+    }
+    error = ERR_get_error();
+  }
+}
+
+
 /* Handle an error reported from the BoringSSL library. */
 static void ThrowIOException(int status,
                              const char* exception_type,
                              const char* message,
                              bool free_message = false) {
   char error_string[SSL_ERROR_MESSAGE_BUFFER_SIZE];
-  error_string[0] = '\0';
-  int error = ERR_get_error();
-  while (error != 0) {
-    int length = strlen(error_string);
-    int free_length = SSL_ERROR_MESSAGE_BUFFER_SIZE - length;
-    if (free_length > 16) {
-      // Enough room for error code at least.
-      if (length > 0) {
-        error_string[length] = '\n';
-        error_string[length + 1] = '\0';
-        length++;
-        free_length--;
-      }
-      ERR_error_string_n(error, error_string + length, free_length);
-      // ERR_error_string_n is guaranteed to leave a null-terminated string.
-    }
-    error = ERR_get_error();
-  }
+  FetchErrorString(error_string, SSL_ERROR_MESSAGE_BUFFER_SIZE);
   OSError os_error_struct(status, error_string, OSError::kBoringSSL);
   Dart_Handle os_error = DartUtils::NewDartOSError(&os_error_struct);
   Dart_Handle exception =
       DartUtils::NewDartIOException(exception_type, message, os_error);
   if (free_message) {
     free(const_cast<char*>(message));
   }
   Dart_ThrowException(exception);
   UNREACHABLE();
 }
@@ skipping 513 matching lines @@
 
   if (filter->ProcessAllBuffers(starts, ends, in_handshake)) {
     CObjectArray* result = new CObjectArray(
         CObject::NewArray(SSLFilter::kNumBuffers * 2));
     for (int i = 0; i < SSLFilter::kNumBuffers; ++i) {
       result->SetAt(2 * i, new CObjectInt32(CObject::NewInt32(starts[i])));
       result->SetAt(2 * i + 1, new CObjectInt32(CObject::NewInt32(ends[i])));
     }
     return result;
   } else {
-    // TODO(24185): Extract the BoringSSL OS error here and return it.
-    int error_code = 1;
-    const char* error_message = "Obsolete PR Error message";
+    int32_t error_code = static_cast<int32_t>(ERR_peek_error());
+    char error_string[SSL_ERROR_MESSAGE_BUFFER_SIZE];
+    FetchErrorString(error_string, SSL_ERROR_MESSAGE_BUFFER_SIZE);
     CObjectArray* result = new CObjectArray(CObject::NewArray(2));
     result->SetAt(0, new CObjectInt32(CObject::NewInt32(error_code)));
-    result->SetAt(1, new CObjectString(CObject::NewString(error_message)));
+    result->SetAt(1, new CObjectString(CObject::NewString(error_string)));
     return result;
   }
 }
 
 
 bool SSLFilter::ProcessAllBuffers(int starts[kNumBuffers],
                                   int ends[kNumBuffers],
                                   bool in_handshake) {
   for (int i = 0; i < kNumBuffers; ++i) {
     if (in_handshake && (i == kReadPlaintext || i == kWritePlaintext)) continue;
@@ skipping 501 matching lines @@
     } else {
       if (SSL_LOG_DATA) Log::Print(
           "WriteEncrypted  BIO_read wrote %d bytes\n", bytes_processed);
     }
   }
   return bytes_processed;
 }
 
 }  // namespace bin
 }  // namespace dart