dart:io | Enable multithreaded secure networking encryption.

tests/standalone/io/raw_secure_server_socket_test.dart

 // Copyright (c) 2013, 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.
 //
 // VMOptions=
 // VMOptions=--short_socket_read
 // VMOptions=--short_socket_write
 // VMOptions=--short_socket_read --short_socket_write
 
 import "package:expect/expect.dart";
@@ skipping 137 matching lines @@
 // between client and server before the connection is secured. This argument
 // only makes sense when both listenSecure and connectSecure are false.
 //
 // postponeSecure
 // When this argument is false the securing of the server end will
 // happen as soon as the last byte of the handshake before securing
 // has been written. When this argument is true the securing of the
 // server will not happen until the first TLS handshake data has been
 // received from the client. This argument only takes effect when
 // handshakeBeforeSecure is true.
-void testSimpleReadWrite(bool listenSecure,
-                         bool connectSecure,
-                         bool handshakeBeforeSecure,
-                         [bool postponeSecure = false]) {
+void testSimpleReadWrite({bool listenSecure,
+                          bool connectSecure,
+                          bool handshakeBeforeSecure,
+                          bool postponeSecure,
+                          bool dropReads}) {
+  int clientReads = 0;
+  int serverReads = 0;
   if (handshakeBeforeSecure == true &&
       (listenSecure == true || connectSecure == true)) {
     Expect.fail("Invalid arguments to testSimpleReadWrite");
   }
 
   ReceivePort port = new ReceivePort();
 
   const messageSize = 1000;
   const handshakeMessageSize = 100;
 
@@ skipping 32 matching lines @@
   Future runServer(RawSocket client) {
     var completer = new Completer();
     int bytesRead = 0;
     int bytesWritten = 0;
     List<int> data = new List<int>(messageSize);
     client.writeEventsEnabled = false;
     var subscription;
     subscription = client.listen((event) {
       switch (event) {
         case RawSocketEvent.READ:
+          if (dropReads) {
+            if (serverReads != 10) {
+              ++serverReads;
+              break;
+            } else {
+              serverReads = 0;
+            }
+          }
           Expect.isTrue(bytesWritten == 0);
           Expect.isTrue(client.available() > 0);
           var buffer = client.read();
           if (buffer != null) {
             data.setRange(bytesRead, bytesRead + buffer.length, buffer);
             bytesRead += buffer.length;
             for (var value in buffer) {
               Expect.isTrue(value is int);
               Expect.isTrue(value < 256 && value >= 0);
             }
@@ skipping 31 matching lines @@
   Future<RawSocket> runClient(RawSocket socket) {
     var completer = new Completer();
     int bytesRead = 0;
     int bytesWritten = 0;
     List<int> dataSent = createTestData();
     List<int> dataReceived = new List<int>(dataSent.length);
     socket.listen((event) {
       switch (event) {
         case RawSocketEvent.READ:
           Expect.isTrue(socket.available() > 0);
+          if (dropReads) {
+            if (clientReads != 10) {
+              ++clientReads;
+              break;
+            } else {
+              clientReads = 0;
+            }
+          }
           var buffer = socket.read();
           if (buffer != null) {
             dataReceived.setRange(bytesRead, bytesRead + buffer.length, buffer);
             bytesRead += buffer.length;
           }
           break;
         case RawSocketEvent.WRITE:
           Expect.isTrue(bytesRead == 0);
           Expect.isFalse(socket.writeEventsEnabled);
           bytesWritten += socket.write(
@@ skipping 19 matching lines @@
     List<int> data = new List<int>(handshakeMessageSize);
     client.writeEventsEnabled = false;
     var subscription;
     subscription = client.listen((event) {
       switch (event) {
         case RawSocketEvent.READ:
           if (bytesRead < data.length) {
             Expect.isTrue(bytesWritten == 0);
           }
           Expect.isTrue(client.available() > 0);
+          if (dropReads) {
+            if (serverReads != 10) {
+              ++serverReads;
+              break;
+            } else {
+              serverReads = 0;
+            }
+          }
           var buffer = client.read();
           if (buffer != null) {
             if (bytesRead == data.length) {
               // Read first part of TLS handshake from client.
               Expect.isTrue(postponeSecure);
               completer.complete([subscription, buffer]);
               client.readEventsEnabled = false;
               return;
             }
             data.setRange(bytesRead, bytesRead + buffer.length, buffer);
@@ skipping 38 matching lines @@
   Future<RawSocket> runClientHandshake(RawSocket socket) {
     var completer = new Completer();
     int bytesRead = 0;
     int bytesWritten = 0;
     List<int> dataSent = createHandshakeTestData();
     List<int> dataReceived = new List<int>(dataSent.length);
     var subscription;
     subscription = socket.listen((event) {
       switch (event) {
         case RawSocketEvent.READ:
+          if (dropReads) {
+            if (clientReads != 10) {
+              ++clientReads;
+              break;
+            } else {
+              clientReads = 0;
+            }
+          }
           Expect.isTrue(socket.available() > 0);
           var buffer = socket.read();
           if (buffer != null) {
             dataReceived.setRange(bytesRead, bytesRead + buffer.length, buffer);
             bytesRead += buffer.length;
             if (bytesRead == dataSent.length) {
               verifyHandshakeTestData(dataReceived);
               completer.complete(subscription);
             }
           }
@@ skipping 39 matching lines @@
       } else if (!handshakeBeforeSecure) {
         RawSecureSocket.secureServer(client, CERTIFICATE).then((client) {
           runServer(client).then((_) => server.close());
         });
       } else {
         runServerHandshake(client).then((secure) {
             RawSecureSocket.secureServer(
                 client,
                 CERTIFICATE,
                 subscription: secure[0],
-                carryOverData: secure[1]).then((client) {
+                bufferedData: secure[1]).then((client) {
             runServer(client).then((_) => server.close());
           });
         });
       }
     });
 
     connectClient(server.port).then(runClient).then((socket) {
       socket.close();
       port.close();
     });
@@ skipping 15 matching lines @@
                           useBuiltinRoots: false);
   testSimpleBind();
   testInvalidBind();
   testSimpleConnect(CERTIFICATE);
   testSimpleConnect("CN=localhost");
   testSimpleConnectFail("not_a_nickname", false);
   testSimpleConnectFail("CN=notARealDistinguishedName", false);
   testSimpleConnectFail("not_a_nickname", true);
   testSimpleConnectFail("CN=notARealDistinguishedName", true);
   testServerListenAfterConnect();
-  testSimpleReadWrite(true, true, false);
-  testSimpleReadWrite(true, false, false);
-  testSimpleReadWrite(false, true, false);
-  testSimpleReadWrite(false, false, false);
-  testSimpleReadWrite(false, false, true, true);
-  testSimpleReadWrite(false, false, true, false);
+  testSimpleReadWrite(listenSecure: true,
+                      connectSecure: true,
+                      handshakeBeforeSecure: false,
+                      postponeSecure: false,
+                      dropReads: false);
+  testSimpleReadWrite(listenSecure: true,
+                      connectSecure: false,
+                      handshakeBeforeSecure: false,
+                      postponeSecure: false,
+                      dropReads: false);
+  testSimpleReadWrite(listenSecure: false,
+                      connectSecure: true,
+                      handshakeBeforeSecure: false,
+                      postponeSecure: false,
+                      dropReads: false);
+  testSimpleReadWrite(listenSecure: false,
+                      connectSecure: false,
+                      handshakeBeforeSecure: false,
+                      postponeSecure: false,
+                      dropReads: false);
+  testSimpleReadWrite(listenSecure: false,
+                      connectSecure: false,
+                      handshakeBeforeSecure: true,
+                      postponeSecure: true,
+                      dropReads: false);
+  testSimpleReadWrite(listenSecure: false,
+                      connectSecure: false,
+                      handshakeBeforeSecure: true,
+                      postponeSecure: false,
+                      dropReads: false);
+  testSimpleReadWrite(listenSecure: true,
+                      connectSecure: true,
+                      handshakeBeforeSecure: false,
+                      postponeSecure: false,
+                      dropReads: true);
+  testSimpleReadWrite(listenSecure: false,
+                      connectSecure: false,
+                      handshakeBeforeSecure: true,
+                      postponeSecure: true,
+                      dropReads: true);
 }