dart:io | Pass errors from multithreaded encryption back 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 296 matching lines @@
   CObjectIntptr filter_object(args[0]);
   SSLFilter* filter = reinterpret_cast<SSLFilter*>(filter_object.Value());
   bool in_handshake = CObjectBool(args[1]).Value();
   int starts[SSLFilter::kNumBuffers];
   int ends[SSLFilter::kNumBuffers];
   for (int i = 0; i < SSLFilter::kNumBuffers; ++i) {
     starts[i] = CObjectInt32(args[2 * i + 2]).Value();
     ends[i] = CObjectInt32(args[2 * i + 3]).Value();
   }
 
-  filter->ProcessAllBuffers(starts, ends, in_handshake);
-
-  for (int i = 0; i < SSLFilter::kNumBuffers; ++i) {
-    args[2 * i + 2]->AsApiCObject()->value.as_int32 = starts[i];
-    args[2 * i + 3]->AsApiCObject()->value.as_int32 = ends[i];
+  if (filter->ProcessAllBuffers(starts, ends, in_handshake)) {
+    for (int i = 0; i < SSLFilter::kNumBuffers; ++i) {
+      args[2 * i + 2]->AsApiCObject()->value.as_int32 = starts[i];
+      args[2 * i + 3]->AsApiCObject()->value.as_int32 = ends[i];
+    }
+    Dart_PostCObject(reply_port_id, args.AsApiCObject());
+  } else {
+    PRErrorCode error_code = PR_GetError();
+    const char* error_message = PR_ErrorToString(error_code, PR_LANGUAGE_EN);
+    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)));
+    Dart_PostCObject(reply_port_id, result->AsApiCObject());
   }
-  Dart_PostCObject(reply_port_id, args.AsApiCObject());
 }
 
 
-void SSLFilter::ProcessAllBuffers(int starts[kNumBuffers],
+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;
     int start = starts[i];
     int end = ends[i];
     int size = isBufferEncrypted(i) ? encrypted_buffer_size_ : buffer_size_;
     if (start < 0 || end < 0 || start >= size || end >= size) {
       FATAL("Out-of-bounds internal buffer access in dart:io SecureSocket");
     }
     switch (i) {
       case kReadPlaintext:
       case kWriteEncrypted:
         // Write data to the circular buffer's free space.  If the buffer
         // is full, neither if statement is executed and nothing happens.
         if (start <= end) {
           // If the free space may be split into two segments,
           // then the first is [end, size), unless start == 0.
           // Then, since the last free byte is at position start - 2,
           // the interval is [end, size - 1).
           int buffer_end = (start == 0) ? size - 1 : size;
           int bytes = (i == kReadPlaintext) ?
               ProcessReadPlaintextBuffer(end, buffer_end) :
               ProcessWriteEncryptedBuffer(end, buffer_end);
+          if (bytes < 0) return false;
           end += bytes;
           ASSERT(end <= size);
           if (end == size) end = 0;
         }
         if (start > end + 1) {
           int bytes =  (i == kReadPlaintext) ?
               ProcessReadPlaintextBuffer(end, start - 1) :
               ProcessWriteEncryptedBuffer(end, start - 1);
+          if (bytes < 0) return false;
           end += bytes;
           ASSERT(end < start);
         }
         ends[i] = end;
         break;
       case kReadEncrypted:
         // Read data from circular buffer.
         if (end < start) {
           // Data may be split into two segments.  In this case,
           // the first is [start, size).
           int bytes = ProcessReadEncryptedBuffer(start, size);
+          if (bytes < 0) return false;
           start += bytes;
           ASSERT(start <= size);
           if (start == size) start = 0;
         }
         if (start < end) {
           int bytes = ProcessReadEncryptedBuffer(start, end);
+          if (bytes < 0) return false;
           start += bytes;
           ASSERT(start <= end);
         }
         starts[i] = start;
         break;
       case kWritePlaintext:
         if (end < start) {
           // Data is split into two segments, [start, size) and [0, end).
           int bytes = ProcessWritePlaintextBuffer(start, size, 0, end);
+          if (bytes < 0) return false;
           start += bytes;
           if (start >= size) start -= size;
         } else {
           int bytes = ProcessWritePlaintextBuffer(start, end, 0, 0);
+          if (bytes < 0) return false;
           start += bytes;
           ASSERT(start <= end);
         }
         starts[i] = start;
         break;
       default:
         UNREACHABLE();
     }
   }
+  return true;
 }
 
 
 static Dart_Handle X509FromCertificate(CERTCertificate* certificate) {
   PRTime start_validity;
   PRTime end_validity;
   SECStatus status =
       CERT_GetCertTimes(certificate, &start_validity, &end_validity);
   if (status != SECSuccess) {
     ThrowPRException("CertificateException",
@@ skipping 422 matching lines @@
   int length = end - start;
   int bytes_processed = 0;
   if (length > 0) {
     bytes_processed = PR_Read(filter_,
                               buffers_[kReadPlaintext] + start,
                               length);
     if (bytes_processed < 0) {
       ASSERT(bytes_processed == -1);
       PRErrorCode pr_error = PR_GetError();
       if (PR_WOULD_BLOCK_ERROR != pr_error) {
-        // TODO(11383): Handle unexpected errors here.
-        FATAL("Error reading plaintext from SSLFilter");
+        return -1;
       }
       bytes_processed = 0;
     }
   }
   return bytes_processed;
 }
 
 
 intptr_t SSLFilter::ProcessWritePlaintextBuffer(int start1, int end1,
                                                 int start2, int end2) {
   PRIOVec ranges[2];
   uint8_t* buffer = buffers_[kWritePlaintext];
   ranges[0].iov_base = reinterpret_cast<char*>(buffer + start1);
   ranges[0].iov_len = end1 - start1;
   ranges[1].iov_base = reinterpret_cast<char*>(buffer + start2);
   ranges[1].iov_len = end2 - start2;
   int bytes_processed = PR_Writev(filter_, ranges, 2, PR_INTERVAL_NO_TIMEOUT);
   if (bytes_processed < 0) {
     ASSERT(bytes_processed == -1);
     PRErrorCode pr_error = PR_GetError();
     if (PR_WOULD_BLOCK_ERROR != pr_error) {
-      // TODO(11383): Handle unexpected errors here.
-      FATAL("Error reading plaintext from SSLFilter");
+      return -1;
     }
     bytes_processed = 0;
   }
   return bytes_processed;
 }
 
 
 intptr_t SSLFilter::ProcessReadEncryptedBuffer(int start, int end) {
   int length = end - start;
   int bytes_processed = 0;
@@ skipping 53 matching lines @@
     // Return a send port for the service port.
     Dart_Handle send_port = Dart_NewSendPort(service_port);
     Dart_SetReturnValue(args, send_port);
   }
   Dart_ExitScope();
 }
 
 
 }  // namespace bin
 }  // namespace dart