src/net/udp/udp_socket_win.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_UDP_UDP_SOCKET_WIN_H_
   6 #define NET_UDP_UDP_SOCKET_WIN_H_
   7
   8 #include <winsock2.h>
   9
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/threading/non_thread_safe.h"
  13 #include "base/win/object_watcher.h"
  14 #include "net/base/completion_callback.h"
  15 #include "net/base/net_export.h"
  16 #include "net/base/rand_callback.h"
  17 #include "net/base/ip_endpoint.h"
  18 #include "net/base/io_buffer.h"
  19 #include "net/base/net_log.h"
  20 #include "net/udp/datagram_socket.h"
  21
  22 namespace net {
  23
  24 class NET_EXPORT UDPSocketWin : NON_EXPORTED_BASE(public base::NonThreadSafe) {
  25  public:
  26   UDPSocketWin(DatagramSocket::BindType bind_type,
  27                const RandIntCallback& rand_int_cb,
  28                net::NetLog* net_log,
  29                const net::NetLog::Source& source);
  30   virtual ~UDPSocketWin();
  31
  32   // Connect the socket to connect with a certain |address|.
  33   // Returns a net error code.
  34   int Connect(const IPEndPoint& address);
  35
  36   // Bind the address/port for this socket to |address|.  This is generally
  37   // only used on a server.
  38   // Returns a net error code.
  39   int Bind(const IPEndPoint& address);
  40
  41   // Close the socket.
  42   void Close();
  43
  44   // Copy the remote udp address into |address| and return a network error code.
  45   int GetPeerAddress(IPEndPoint* address) const;
  46
  47   // Copy the local udp address into |address| and return a network error code.
  48   // (similar to getsockname)
  49   int GetLocalAddress(IPEndPoint* address) const;
  50
  51   // IO:
  52   // Multiple outstanding read requests are not supported.
  53   // Full duplex mode (reading and writing at the same time) is supported
  54
  55   // Read from the socket.
  56   // Only usable from the client-side of a UDP socket, after the socket
  57   // has been connected.
  58   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
  59
  60   // Write to the socket.
  61   // Only usable from the client-side of a UDP socket, after the socket
  62   // has been connected.
  63   int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
  64
  65   // Read from a socket and receive sender address information.
  66   // |buf| is the buffer to read data into.
  67   // |buf_len| is the maximum amount of data to read.
  68   // |address| is a buffer provided by the caller for receiving the sender
  69   //   address information about the received data.  This buffer must be kept
  70   //   alive by the caller until the callback is placed.
  71   // |address_length| is a ptr to the length of the |address| buffer.  This
  72   //   is an input parameter containing the maximum size |address| can hold
  73   //   and also an output parameter for the size of |address| upon completion.
  74   // |callback| the callback on completion of the Recv.
  75   // Returns a net error code, or ERR_IO_PENDING if the IO is in progress.
  76   // If ERR_IO_PENDING is returned, the caller must keep |buf|, |address|,
  77   // and |address_length| alive until the callback is called.
  78   int RecvFrom(IOBuffer* buf,
  79                int buf_len,
  80                IPEndPoint* address,
  81                const CompletionCallback& callback);
  82
  83   // Send to a socket with a particular destination.
  84   // |buf| is the buffer to send
  85   // |buf_len| is the number of bytes to send
  86   // |address| is the recipient address.
  87   // |address_length| is the size of the recipient address
  88   // |callback| is the user callback function to call on complete.
  89   // Returns a net error code, or ERR_IO_PENDING if the IO is in progress.
  90   // If ERR_IO_PENDING is returned, the caller must keep |buf| and |address|
  91   // alive until the callback is called.
  92   int SendTo(IOBuffer* buf,
  93              int buf_len,
  94              const IPEndPoint& address,
  95              const CompletionCallback& callback);
  96
  97   // Set the receive buffer size (in bytes) for the socket.
  98   bool SetReceiveBufferSize(int32 size);
  99
 100   // Set the send buffer size (in bytes) for the socket.
 101   bool SetSendBufferSize(int32 size);
 102
 103   // Returns true if the socket is already connected or bound.
 104   bool is_connected() const { return socket_ != INVALID_SOCKET; }
 105
 106   const BoundNetLog& NetLog() const { return net_log_; }
 107
 108   // Sets corresponding flags in |socket_options_| to allow the socket
 109   // to share the local address to which the socket will be bound with
 110   // other processes. Should be called before Bind().
 111   void AllowAddressReuse();
 112
 113   // Sets corresponding flags in |socket_options_| to allow sending
 114   // and receiving packets to and from broadcast addresses. Should be
 115   // called before Bind().
 116   void AllowBroadcast();
 117
 118   // Join the multicast group.
 119   // |group_address| is the group address to join, could be either
 120   // an IPv4 or IPv6 address.
 121   // Return a network error code.
 122   int JoinGroup(const IPAddressNumber& group_address) const;
 123
 124   // Leave the multicast group.
 125   // |group_address| is the group address to leave, could be either
 126   // an IPv4 or IPv6 address. If the socket hasn't joined the group,
 127   // it will be ignored.
 128   // It's optional to leave the multicast group before destroying
 129   // the socket. It will be done by the OS.
 130   // Return a network error code.
 131   int LeaveGroup(const IPAddressNumber& group_address) const;
 132
 133   // Set the time-to-live option for UDP packets sent to the multicast
 134   // group address. The default value of this option is 1.
 135   // Cannot be negative or more than 255.
 136   // Should be called before Bind().
 137   int SetMulticastTimeToLive(int time_to_live);
 138
 139   // Set the loopback flag for UDP socket. If this flag is true, the host
 140   // will receive packets sent to the joined group from itself.
 141   // The default value of this option is true.
 142   // Should be called before Bind().
 143   //
 144   // Note: the behavior of |SetMulticastLoopbackMode| is slightly
 145   // different between Windows and Unix-like systems. The inconsistency only
 146   // happens when there are more than one applications on the same host
 147   // joined to the same multicast group while having different settings on
 148   // multicast loopback mode. On Windows, the applications with loopback off
 149   // will not RECEIVE the loopback packets; while on Unix-like systems, the
 150   // applications with loopback off will not SEND the loopback packets to
 151   // other applications on the same host. See MSDN: http://goo.gl/6vqbj
 152   int SetMulticastLoopbackMode(bool loopback);
 153
 154   // Set the differentiated services flags on outgoing packets. May not
 155   // do anything on some platforms.
 156   int SetDiffServCodePoint(DiffServCodePoint dscp);
 157
 158  private:
 159   enum SocketOptions {
 160     SOCKET_OPTION_REUSE_ADDRESS  = 1 << 0,
 161     SOCKET_OPTION_BROADCAST      = 1 << 1,
 162     SOCKET_OPTION_MULTICAST_LOOP = 1 << 2
 163   };
 164
 165   class Core;
 166
 167   void DoReadCallback(int rv);
 168   void DoWriteCallback(int rv);
 169   void DidCompleteRead();
 170   void DidCompleteWrite();
 171
 172   // Handles stats and logging. |result| is the number of bytes transferred, on
 173   // success, or the net error code on failure. LogRead retrieves the address
 174   // from |recv_addr_storage_|, while LogWrite takes it as an optional argument.
 175   void LogRead(int result, const char* bytes) const;
 176   void LogWrite(int result, const char* bytes, const IPEndPoint* address) const;
 177
 178   // Returns the OS error code (or 0 on success).
 179   int CreateSocket(const IPEndPoint& address);
 180
 181   // Same as SendTo(), except that address is passed by pointer
 182   // instead of by reference. It is called from Write() with |address|
 183   // set to NULL.
 184   int SendToOrWrite(IOBuffer* buf,
 185                     int buf_len,
 186                     const IPEndPoint* address,
 187                     const CompletionCallback& callback);
 188
 189   int InternalConnect(const IPEndPoint& address);
 190   int InternalRecvFrom(IOBuffer* buf, int buf_len, IPEndPoint* address);
 191   int InternalSendTo(IOBuffer* buf, int buf_len, const IPEndPoint* address);
 192
 193   // Applies |socket_options_| to |socket_|. Should be called before
 194   // Bind().
 195   int SetSocketOptions();
 196   int DoBind(const IPEndPoint& address);
 197   int RandomBind(const IPEndPoint& address);
 198
 199   // Attempts to convert the data in |recv_addr_storage_| and |recv_addr_len_|
 200   // to an IPEndPoint and writes it to |address|. Returns true on success.
 201   bool ReceiveAddressToIPEndpoint(IPEndPoint* address) const;
 202
 203   SOCKET socket_;
 204   int addr_family_;
 205
 206   // Bitwise-or'd combination of SocketOptions. Specifies the set of
 207   // options that should be applied to |socket_| before Bind().
 208   int socket_options_;
 209
 210   // Multicast socket options cached for SetSocketOption.
 211   // Cannot be used after Bind().
 212   int multicast_time_to_live_;
 213
 214   // How to do source port binding, used only when UDPSocket is part of
 215   // UDPClientSocket, since UDPServerSocket provides Bind.
 216   DatagramSocket::BindType bind_type_;
 217
 218   // PRNG function for generating port numbers.
 219   RandIntCallback rand_int_cb_;
 220
 221   // These are mutable since they're just cached copies to make
 222   // GetPeerAddress/GetLocalAddress smarter.
 223   mutable scoped_ptr<IPEndPoint> local_address_;
 224   mutable scoped_ptr<IPEndPoint> remote_address_;
 225
 226   // The core of the socket that can live longer than the socket itself. We pass
 227   // resources to the Windows async IO functions and we have to make sure that
 228   // they are not destroyed while the OS still references them.
 229   scoped_refptr<Core> core_;
 230
 231   IPEndPoint* recv_from_address_;
 232
 233   // Cached copy of the current address we're sending to, if any.  Used for
 234   // logging.
 235   scoped_ptr<IPEndPoint> send_to_address_;
 236
 237   // External callback; called when read is complete.
 238   CompletionCallback read_callback_;
 239
 240   // External callback; called when write is complete.
 241   CompletionCallback write_callback_;
 242
 243   BoundNetLog net_log_;
 244
 245   DISALLOW_COPY_AND_ASSIGN(UDPSocketWin);
 246 };
 247
 248 }  // namespace net
 249
 250 #endif  // NET_UDP_UDP_SOCKET_WIN_H_