Add UDP support to dart:io

runtime/bin/eventhandler_win.h

 // 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.
 
 #ifndef BIN_EVENTHANDLER_WIN_H_
 #define BIN_EVENTHANDLER_WIN_H_
 
 #if !defined(BIN_EVENTHANDLER_H_)
 #error Do not include eventhandler_win.h directly; use eventhandler.h instead.
 #endif
 
 #include <winsock2.h>
+#include <ws2tcpip.h>

[Anders Johnsen, 2013/12/12 12:19:58]

This looks odd - importing a TCP/IP header for UDP CL? Is it just how Windows
headers was made? :)

[Søren Gjesse, 2013/12/12 15:44:39]

It contains the typedef for socklen_t.

 #include <mswsock.h>
 
 #include "bin/builtin.h"
 #include "platform/thread.h"
 
 
 namespace dart {
 namespace bin {
 
 // Forward declarations.
@@ skipping 10 matching lines @@
   Dart_Port dart_port;
   int64_t data;
 };
 
 
 // An OverlappedBuffer encapsulates the OVERLAPPED structure and the
 // associated data buffer. For accept it also contains the pre-created
 // socket for the client.
 class OverlappedBuffer {
  public:
-  enum Operation { kAccept, kRead, kWrite, kDisconnect };
+  enum Operation { kAccept, kRead, kRecvFrom, kWrite, kSendTo, kDisconnect };
 
   static OverlappedBuffer* AllocateAcceptBuffer(int buffer_size);
   static OverlappedBuffer* AllocateReadBuffer(int buffer_size);
+  static OverlappedBuffer* AllocateRecvFromBuffer(int buffer_size);
   static OverlappedBuffer* AllocateWriteBuffer(int buffer_size);
+  static OverlappedBuffer* AllocateSendToBuffer(int buffer_size);
   static OverlappedBuffer* AllocateDisconnectBuffer();
   static void DisposeBuffer(OverlappedBuffer* buffer);
 
   // Find the IO buffer from the OVERLAPPED address.
   static OverlappedBuffer* GetFromOverlapped(OVERLAPPED* overlapped);
 
   // Read data from a buffer which has been received. It will read up
   // to num_bytes bytes of data returning the actual number of bytes
   // read. This will update the index of the next byte in the buffer
   // so calling Read several times will keep returning new data from
   // the buffer until all data have been read.
   int Read(void* buffer, int num_bytes);
 
   // Write data to a buffer before sending it. Returns the number of bytes
   // actually written to the buffer. Calls to Write will always write to
   // the buffer from the begining.
   int Write(const void* buffer, int num_bytes);
 
   // Check the amount of data in a read buffer which has not been read yet.
   int GetRemainingLength();
   bool IsEmpty() { return GetRemainingLength() == 0; }
 
   Operation operation() { return operation_; }
   SOCKET client() { return client_; }
   char* GetBufferStart() { return reinterpret_cast<char*>(&buffer_data_); }
   int GetBufferSize() { return buflen_; }
+  struct sockaddr* from() { return from_; }
+  socklen_t* from_len_addr() { return from_len_addr_; }
+  socklen_t from_len() { return from_ == NULL ? 0 : *from_len_addr_; }
 
   // Returns the address of the OVERLAPPED structure with all fields
   // initialized to zero.
   OVERLAPPED* GetCleanOverlapped() {
     memset(&overlapped_, 0, sizeof(overlapped_));
     return &overlapped_;
   }
 
   // Returns a WASBUF structure initialized with the data in this IO buffer.
   WSABUF* GetWASBUF() {
     wbuf_.buf = GetBufferStart();
     wbuf_.len = GetBufferSize();
     return &wbuf_;
   };
 
   void set_data_length(int data_length) { data_length_ = data_length; }
 
  private:
   OverlappedBuffer(int buffer_size, Operation operation)
       : operation_(operation), buflen_(buffer_size) {
     memset(GetBufferStart(), 0, GetBufferSize());
+    if (operation == kRecvFrom) {
+      // Reserve part of the buffer for the length of source sockaddr
+      // and source sockaddr.
+      static int additional_size =

[Anders Johnsen, 2013/12/12 12:19:58]

static -> const?

[Søren Gjesse, 2013/12/12 15:44:39]

Done.

+        sizeof(struct sockaddr_storage) + sizeof(socklen_t);

[Anders Johnsen, 2013/12/12 12:19:58]

Indentation

[Søren Gjesse, 2013/12/12 15:44:39]

Done.

+      ASSERT(buflen_ > additional_size);
+      buflen_ -= additional_size;
+      from_len_addr_ = reinterpret_cast<socklen_t*>(
+          GetBufferStart() + GetBufferSize());
+      *from_len_addr_ = sizeof(struct sockaddr_storage);
+      from_ = reinterpret_cast<struct sockaddr*>(from_len_addr_ + 1);
+    } else {
+      from_len_addr_ = NULL;
+      from_ = NULL;
+    }
     index_ = 0;
     data_length_ = 0;
     if (operation_ == kAccept) {
       client_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     }
   }
 
   void* operator new(size_t size, int buffer_size) {
     return malloc(size + buffer_size);
   }
 
   void operator delete(void* buffer) {
     free(buffer);
   }
 
+  // Allocate an overlapped buffer for thse specified amount of data and
+  // operation. Some operations need additional buffer space, which is
+  // handled by this method.
   static OverlappedBuffer* AllocateBuffer(int buffer_size,
                                           Operation operation);
 
   OVERLAPPED overlapped_;  // OVERLAPPED structure for overlapped IO.
   SOCKET client_;  // Used for AcceptEx client socket.
   int buflen_;  // Length of the buffer.
   Operation operation_;  // Type of operation issued.
 
   int index_;  // Index for next read from read buffer.
   int data_length_;  // Length of the actual data in the buffer.
 
   WSABUF wbuf_;  // Structure for passing buffer to WSA functions.
 
+  // For the recvfrom operation additional storace is allocated for the
+  // source sockaddr.
+  socklen_t* from_len_addr_;  // Pointer to source sockaddr size storage.
+  struct sockaddr* from_;  // Pointer to source sockaddr storage.
+
   // Buffer for recv/send/AcceptEx. This must be at the end of the
   // object as the object is allocated larger than it's definition
   // indicate to extend this array.
   uint8_t buffer_data_[1];
 };
 
 
 // Abstract super class for holding information on listen and connected
 // sockets.
 class Handle {
  public:
   enum Type {
     kFile,
     kStd,
     kDirectoryWatch,
     kClientSocket,
-    kListenSocket
+    kListenSocket,
+    kDatagramSocket
   };
 
   class ScopedLock {
    public:
     explicit ScopedLock(Handle* handle)
         : handle_(handle) {
       handle_->Lock();
     }
     ~ScopedLock() {
       handle_->Unlock();
     }
 
    private:
     Handle* handle_;
   };
 
   virtual ~Handle();
 
   // Socket interface exposing normal socket operations.
   int Available();
   int Read(void* buffer, int num_bytes);
+  int RecvFrom(
+      void* buffer, int num_bytes, struct sockaddr* sa, socklen_t addr_len);
   virtual int Write(const void* buffer, int num_bytes);
+  virtual int SendTo(const void* buffer,
+                     int num_bytes,
+                     struct sockaddr* sa,
+                     socklen_t sa_len);
 
   // Internal interface used by the event handler.
   virtual bool IssueRead();
+  virtual bool IssueRecvFrom();
   virtual bool IssueWrite();
+  virtual bool IssueSendTo(struct sockaddr* sa, socklen_t sa_len);
   bool HasPendingRead();
   bool HasPendingWrite();
   void ReadComplete(OverlappedBuffer* buffer);
+  void RecvFromComplete(OverlappedBuffer* buffer);
   void WriteComplete(OverlappedBuffer* buffer);
 
   bool IsClosing() { return (flags_ & (1 << kClosing)) != 0; }
   bool IsClosedRead() { return (flags_ & (1 << kCloseRead)) != 0; }
   bool IsClosedWrite() { return (flags_ & (1 << kCloseWrite)) != 0; }
   bool IsError() { return (flags_ & (1 << kError)) != 0; }
   void MarkClosing() { flags_ |= (1 << kClosing); }
   void MarkClosedRead() { flags_ |= (1 << kCloseRead); }
   void MarkClosedWrite() { flags_ |= (1 << kCloseWrite); }
   void MarkError() { flags_ |= (1 << kError); }
@@ skipping 13 matching lines @@
   void Close();
   virtual void DoClose();
   virtual bool IsClosed() = 0;
 
   void SetPortAndMask(Dart_Port port, intptr_t mask) {
     port_ = port;
     mask_ = mask;
   }
   Type type() { return type_; }
   bool is_file() { return type_ == kFile; }
-  bool is_socket() { return type_ == kListenSocket || type_ == kClientSocket; }
+  bool is_socket() { return type_ == kListenSocket ||
+                            type_ == kClientSocket ||
+                            type_ == kDatagramSocket; }
   bool is_listen_socket() { return type_ == kListenSocket; }
   bool is_client_socket() { return type_ == kClientSocket; }
+  bool is_datagram_socket() { return type_ == kDatagramSocket; }
   void set_mask(intptr_t mask) { mask_ = mask; }
   intptr_t mask() { return mask_; }
 
   void MarkDoesNotSupportOverlappedIO() {
     flags_ |= (1 << kDoesNotSupportOverlappedIO);
   }
   bool SupportsOverlappedIO() {
     return (flags_ & (1 << kDoesNotSupportOverlappedIO)) == 0;
   }
 
@@ skipping 194 matching lines @@
   void set_next(ClientSocket* next) { next_ = next; }
 
  private:
   bool LoadDisconnectEx();
 
   LPFN_DISCONNECTEX DisconnectEx_;
   ClientSocket* next_;
 };
 
 
+class DatagramSocket : public SocketHandle {
+ public:
+  explicit DatagramSocket(SOCKET s) : SocketHandle(s) {
+    type_ = kDatagramSocket;
+  }
+
+  virtual ~DatagramSocket() {
+    // Don't delete this object until all pending requests have been handled.
+    ASSERT(!HasPendingRead());
+    ASSERT(!HasPendingWrite());
+  };
+
+  // Internal interface used by the event handler.
+  virtual bool IssueRecvFrom();
+  virtual bool IssueSendTo(sockaddr* sa, socklen_t sa_len);
+
+  virtual void EnsureInitialized(EventHandlerImplementation* event_handler);
+  virtual void DoClose();
+  virtual bool IsClosed();
+};
+
 // Event handler.
 class EventHandlerImplementation {
  public:
   EventHandlerImplementation();
   virtual ~EventHandlerImplementation();
 
   void SendData(intptr_t id, Dart_Port dart_port, int64_t data);
   void Start(EventHandler* handler);
   void Shutdown();
 
   static void EventHandlerEntry(uword args);
 
   int64_t GetTimeout();
   void HandleInterrupt(InterruptMessage* msg);
   void HandleTimeout();
   void HandleAccept(ListenSocket* listen_socket, OverlappedBuffer* buffer);
   void HandleClosed(Handle* handle);
   void HandleError(Handle* handle);
   void HandleRead(Handle* handle, int bytes, OverlappedBuffer* buffer);
+  void HandleRecvFrom(Handle* handle, int bytes, OverlappedBuffer* buffer);
   void HandleWrite(Handle* handle, int bytes, OverlappedBuffer* buffer);
   void HandleDisconnect(ClientSocket* client_socket,
                         int bytes,
                         OverlappedBuffer* buffer);
   void HandleIOCompletion(DWORD bytes, ULONG_PTR key, OVERLAPPED* overlapped);
 
   HANDLE completion_port() { return completion_port_; }
 
  private:
   ClientSocket* client_sockets_head_;
 
   TimeoutQueue timeout_queue_;  // Time for next timeout.
   bool shutdown_;
   HANDLE completion_port_;
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_EVENTHANDLER_WIN_H_