Correctly truncate in Windows eventhandler.

runtime/bin/eventhandler_win.cc

 // 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.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/eventhandler.h"
 
 #include <winsock2.h>  // NOLINT
@@ skipping 588 matching lines @@
     LoadAcceptEx();
   }
 }
 
 
 bool ListenSocket::IsClosed() {
   return IsClosing() && !HasPendingAccept();
 }
 
 
-int Handle::Available() {
+intptr_t Handle::Available() {
   ScopedLock lock(this);
   if (data_ready_ == NULL) return 0;
   ASSERT(!data_ready_->IsEmpty());
   return data_ready_->GetRemainingLength();
 }
 
 
-int Handle::Read(void* buffer, int num_bytes) {
+intptr_t Handle::Read(void* buffer, intptr_t num_bytes) {
   ScopedLock lock(this);
   if (data_ready_ == NULL) return 0;
-  num_bytes = data_ready_->Read(buffer, num_bytes);
+  num_bytes = data_ready_->Read(
+      buffer, Utils::Minimum<intptr_t>(num_bytes, INT_MAX));
   if (data_ready_->IsEmpty()) {
     OverlappedBuffer::DisposeBuffer(data_ready_);
     data_ready_ = NULL;
     if (!IsClosing() && !IsClosedRead()) IssueRead();
   }
   return num_bytes;
 }
 
 
-int Handle::RecvFrom(
-    void* buffer, int num_bytes, struct sockaddr* sa, socklen_t sa_len) {
+intptr_t Handle::RecvFrom(
+    void* buffer, intptr_t num_bytes, struct sockaddr* sa, socklen_t sa_len) {
   ScopedLock lock(this);
   if (data_ready_ == NULL) return 0;
-  num_bytes = data_ready_->Read(buffer, num_bytes);
+  num_bytes = data_ready_->Read(
+      buffer, Utils::Minimum<intptr_t>(num_bytes, INT_MAX));
   if (data_ready_->from()->sa_family == AF_INET) {
     ASSERT(sa_len >= sizeof(struct sockaddr_in));
     memmove(sa, data_ready_->from(), sizeof(struct sockaddr_in));
   } else {
     ASSERT(data_ready_->from()->sa_family == AF_INET6);
     ASSERT(sa_len >= sizeof(struct sockaddr_in6));
     memmove(sa, data_ready_->from(), sizeof(struct sockaddr_in6));
   }
   // Always dispose of the buffer, as UDP messages must be read in their
   // entirety to match how recvfrom works in a socket.
   OverlappedBuffer::DisposeBuffer(data_ready_);
   data_ready_ = NULL;
   if (!IsClosing() && !IsClosedRead()) IssueRecvFrom();
   return num_bytes;
 }
 
 
-int Handle::Write(const void* buffer, int num_bytes) {
+intptr_t Handle::Write(const void* buffer, intptr_t num_bytes) {
   ScopedLock lock(this);
   if (pending_write_ != NULL) return 0;
   if (num_bytes > kBufferSize) num_bytes = kBufferSize;
   ASSERT(SupportsOverlappedIO());
   if (completion_port_ == INVALID_HANDLE_VALUE) return 0;
-  pending_write_ = OverlappedBuffer::AllocateWriteBuffer(num_bytes);
-  pending_write_->Write(buffer, num_bytes);
+  int truncated_bytes = Utils::Minimum<intptr_t>(num_bytes, INT_MAX);
+  pending_write_ = OverlappedBuffer::AllocateWriteBuffer(truncated_bytes);
+  pending_write_->Write(buffer, truncated_bytes);
   if (!IssueWrite()) return -1;
-  return num_bytes;
+  return truncated_bytes;
 }
 
 
-int Handle::SendTo(
-    const void* buffer, int num_bytes, struct sockaddr* sa, socklen_t sa_len) {
+intptr_t Handle::SendTo(const void* buffer,
+                        intptr_t num_bytes,
+                        struct sockaddr* sa,
+                        socklen_t sa_len) {
   ScopedLock lock(this);
   if (pending_write_ != NULL) return 0;
   if (num_bytes > kBufferSize) num_bytes = kBufferSize;
   ASSERT(SupportsOverlappedIO());
   if (completion_port_ == INVALID_HANDLE_VALUE) return 0;
   pending_write_ = OverlappedBuffer::AllocateSendToBuffer(num_bytes);
   pending_write_->Write(buffer, num_bytes);
   if (!IssueSendTo(sa, sa_len)) return -1;
   return num_bytes;
 }
@@ skipping 41 matching lines @@
   OVERLAPPED* overlapped = pending_write_->GetCleanOverlapped();
   ok = PostQueuedCompletionStatus(event_handler_->completion_port(),
                                   bytes_written,
                                   reinterpret_cast<ULONG_PTR>(this),
                                   overlapped);
   if (!ok) {
     FATAL("PostQueuedCompletionStatus failed");
   }
 }
 
-int StdHandle::Write(const void* buffer, int num_bytes) {
+intptr_t StdHandle::Write(const void* buffer, intptr_t num_bytes) {
   ScopedLock lock(this);
   if (pending_write_ != NULL) return 0;
   if (num_bytes > kBufferSize) num_bytes = kBufferSize;
   // In the case of stdout and stderr, OverlappedIO is not supported.
   // Here we'll instead use a thread, to make it async.
   // This code is actually never exposed to the user, as stdout and stderr is
   // not available as a RawSocket, but only wrapped in a Socket.
   // Note that we return '0', unless a thread have already completed a write.
   MonitorLocker locker(write_monitor_);
   if (thread_wrote_ > 0) {
     if (num_bytes > thread_wrote_) num_bytes = thread_wrote_;
     thread_wrote_ -= num_bytes;
     return num_bytes;
   }
   if (!write_thread_exists_) {
     write_thread_exists_ = true;
     int result = dart::Thread::Start(WriteFileThread,
                                      reinterpret_cast<uword>(this));
     if (result != 0) {
       FATAL1("Failed to start write file thread %d", result);
     }
     while (!write_thread_running_) {
       // Wait until we the thread is running.
       locker.Wait(Monitor::kNoTimeout);
     }
   }
+  // Only queue up to INT_MAX bytes.
+  int truncated_bytes = Utils::Minimum<intptr_t>(num_bytes, INT_MAX);
   // Create buffer and notify thread about the new handle.
-  pending_write_ = OverlappedBuffer::AllocateWriteBuffer(num_bytes);
-  pending_write_->Write(buffer, num_bytes);
+  pending_write_ = OverlappedBuffer::AllocateWriteBuffer(truncated_bytes);
+  pending_write_->Write(buffer, truncated_bytes);
   locker.Notify();
   return 0;
 }
 
 
 void StdHandle::DoClose() {
   MonitorLocker locker(write_monitor_);
   if (write_thread_exists_) {
     write_thread_running_ = false;
     locker.Notify();
@@ skipping 597 matching lines @@
 
 
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)