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_LIBEVENT_H_ 6#define NET_UDP_UDP_SOCKET_LIBEVENT_H_ 7 8#include "base/memory/ref_counted.h" 9#include "base/memory/scoped_ptr.h" 10#include "base/message_loop/message_loop.h" 11#include "base/threading/non_thread_safe.h" 12#include "net/base/completion_callback.h" 13#include "net/base/io_buffer.h" 14#include "net/base/ip_endpoint.h" 15#include "net/base/net_export.h" 16#include "net/base/net_log.h" 17#include "net/base/rand_callback.h" 18#include "net/socket/socket_descriptor.h" 19#include "net/udp/datagram_socket.h" 20 21namespace net { 22 23class NET_EXPORT UDPSocketLibevent : public base::NonThreadSafe { 24 public: 25 UDPSocketLibevent(DatagramSocket::BindType bind_type, 26 const RandIntCallback& rand_int_cb, 27 net::NetLog* net_log, 28 const net::NetLog::Source& source); 29 virtual ~UDPSocketLibevent(); 30 31 // Connect the socket to connect with a certain |address|. 32 // Returns a net error code. 33 int Connect(const IPEndPoint& address); 34 35 // Bind the address/port for this socket to |address|. This is generally 36 // only used on a server. 37 // Returns a net error code. 38 int Bind(const IPEndPoint& address); 39 40 // Close the socket. 41 void Close(); 42 43 // Copy the remote udp address into |address| and return a network error code. 44 int GetPeerAddress(IPEndPoint* address) const; 45 46 // Copy the local udp address into |address| and return a network error code. 47 // (similar to getsockname) 48 int GetLocalAddress(IPEndPoint* address) const; 49 50 // IO: 51 // Multiple outstanding read requests are not supported. 52 // Full duplex mode (reading and writing at the same time) is supported 53 54 // Read from the socket. 55 // Only usable from the client-side of a UDP socket, after the socket 56 // has been connected. 57 int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback); 58 59 // Write to the socket. 60 // Only usable from the client-side of a UDP socket, after the socket 61 // has been connected. 62 int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback); 63 64 // Read from a socket and receive sender address information. 65 // |buf| is the buffer to read data into. 66 // |buf_len| is the maximum amount of data to read. 67 // |address| is a buffer provided by the caller for receiving the sender 68 // address information about the received data. This buffer must be kept 69 // alive by the caller until the callback is placed. 70 // |address_length| is a ptr to the length of the |address| buffer. This 71 // is an input parameter containing the maximum size |address| can hold 72 // and also an output parameter for the size of |address| upon completion. 73 // |callback| the callback on completion of the Recv. 74 // Returns a net error code, or ERR_IO_PENDING if the IO is in progress. 75 // If ERR_IO_PENDING is returned, the caller must keep |buf|, |address|, 76 // and |address_length| alive until the callback is called. 77 int RecvFrom(IOBuffer* buf, 78 int buf_len, 79 IPEndPoint* address, 80 const CompletionCallback& callback); 81 82 // Send to a socket with a particular destination. 83 // |buf| is the buffer to send 84 // |buf_len| is the number of bytes to send 85 // |address| is the recipient address. 86 // |address_length| is the size of the recipient address 87 // |callback| is the user callback function to call on complete. 88 // Returns a net error code, or ERR_IO_PENDING if the IO is in progress. 89 // If ERR_IO_PENDING is returned, the caller must keep |buf| and |address| 90 // alive until the callback is called. 91 int SendTo(IOBuffer* buf, 92 int buf_len, 93 const IPEndPoint& address, 94 const CompletionCallback& callback); 95 96 // Set the receive buffer size (in bytes) for the socket. 97 int SetReceiveBufferSize(int32 size); 98 99 // Set the send buffer size (in bytes) for the socket. 100 int SetSendBufferSize(int32 size); 101 102 // Returns true if the socket is already connected or bound. 103 bool is_connected() const { return socket_ != kInvalidSocket; } 104 105 const BoundNetLog& NetLog() const { return net_log_; } 106 107 // Sets corresponding flags in |socket_options_| to allow the socket 108 // to share the local address to which the socket will be bound with 109 // other processes. Should be called before Bind(). 110 void AllowAddressReuse(); 111 112 // Sets corresponding flags in |socket_options_| to allow sending 113 // and receiving packets to and from broadcast addresses. Should be 114 // called before Bind(). 115 void AllowBroadcast(); 116 117 // Join the multicast group. 118 // |group_address| is the group address to join, could be either 119 // an IPv4 or IPv6 address. 120 // Return a network error code. 121 int JoinGroup(const IPAddressNumber& group_address) const; 122 123 // Leave the multicast group. 124 // |group_address| is the group address to leave, could be either 125 // an IPv4 or IPv6 address. If the socket hasn't joined the group, 126 // it will be ignored. 127 // It's optional to leave the multicast group before destroying 128 // the socket. It will be done by the OS. 129 // Return a network error code. 130 int LeaveGroup(const IPAddressNumber& group_address) const; 131 132 // Set interface to use for multicast. If |interface_index| set to 0, default 133 // interface is used. 134 // Should be called before Bind(). 135 // Returns a network error code. 136 int SetMulticastInterface(uint32 interface_index); 137 138 // Set the time-to-live option for UDP packets sent to the multicast 139 // group address. The default value of this option is 1. 140 // Cannot be negative or more than 255. 141 // Should be called before Bind(). 142 // Return a network error code. 143 int SetMulticastTimeToLive(int time_to_live); 144 145 // Set the loopback flag for UDP socket. If this flag is true, the host 146 // will receive packets sent to the joined group from itself. 147 // The default value of this option is true. 148 // Should be called before Bind(). 149 // Return a network error code. 150 // 151 // Note: the behavior of |SetMulticastLoopbackMode| is slightly 152 // different between Windows and Unix-like systems. The inconsistency only 153 // happens when there are more than one applications on the same host 154 // joined to the same multicast group while having different settings on 155 // multicast loopback mode. On Windows, the applications with loopback off 156 // will not RECEIVE the loopback packets; while on Unix-like systems, the 157 // applications with loopback off will not SEND the loopback packets to 158 // other applications on the same host. See MSDN: http://goo.gl/6vqbj 159 int SetMulticastLoopbackMode(bool loopback); 160 161 // Set the differentiated services flags on outgoing packets. May not 162 // do anything on some platforms. 163 // Return a network error code. 164 int SetDiffServCodePoint(DiffServCodePoint dscp); 165 166 // Resets the thread to be used for thread-safety checks. 167 void DetachFromThread(); 168 169 private: 170 enum SocketOptions { 171 SOCKET_OPTION_REUSE_ADDRESS = 1 << 0, 172 SOCKET_OPTION_BROADCAST = 1 << 1, 173 SOCKET_OPTION_MULTICAST_LOOP = 1 << 2 174 }; 175 176 class ReadWatcher : public base::MessageLoopForIO::Watcher { 177 public: 178 explicit ReadWatcher(UDPSocketLibevent* socket) : socket_(socket) {} 179 180 // MessageLoopForIO::Watcher methods 181 182 virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE; 183 184 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {} 185 186 private: 187 UDPSocketLibevent* const socket_; 188 189 DISALLOW_COPY_AND_ASSIGN(ReadWatcher); 190 }; 191 192 class WriteWatcher : public base::MessageLoopForIO::Watcher { 193 public: 194 explicit WriteWatcher(UDPSocketLibevent* socket) : socket_(socket) {} 195 196 // MessageLoopForIO::Watcher methods 197 198 virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {} 199 200 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE; 201 202 private: 203 UDPSocketLibevent* const socket_; 204 205 DISALLOW_COPY_AND_ASSIGN(WriteWatcher); 206 }; 207 208 void DoReadCallback(int rv); 209 void DoWriteCallback(int rv); 210 void DidCompleteRead(); 211 void DidCompleteWrite(); 212 213 // Handles stats and logging. |result| is the number of bytes transferred, on 214 // success, or the net error code on failure. On success, LogRead takes in a 215 // sockaddr and its length, which are mandatory, while LogWrite takes in an 216 // optional IPEndPoint. 217 void LogRead(int result, const char* bytes, socklen_t addr_len, 218 const sockaddr* addr) const; 219 void LogWrite(int result, const char* bytes, const IPEndPoint* address) const; 220 221 // Returns the OS error code (or 0 on success). 222 int CreateSocket(int addr_family); 223 224 // Same as SendTo(), except that address is passed by pointer 225 // instead of by reference. It is called from Write() with |address| 226 // set to NULL. 227 int SendToOrWrite(IOBuffer* buf, 228 int buf_len, 229 const IPEndPoint* address, 230 const CompletionCallback& callback); 231 232 int InternalConnect(const IPEndPoint& address); 233 int InternalRecvFrom(IOBuffer* buf, int buf_len, IPEndPoint* address); 234 int InternalSendTo(IOBuffer* buf, int buf_len, const IPEndPoint* address); 235 236 // Applies |socket_options_| to |socket_|. Should be called before 237 // Bind(). 238 int SetSocketOptions(); 239 int DoBind(const IPEndPoint& address); 240 // Binds to a random port on |address|. 241 int RandomBind(const IPAddressNumber& address); 242 243 int socket_; 244 int addr_family_; 245 246 // Bitwise-or'd combination of SocketOptions. Specifies the set of 247 // options that should be applied to |socket_| before Bind(). 248 int socket_options_; 249 250 // Multicast interface. 251 uint32 multicast_interface_; 252 253 // Multicast socket options cached for SetSocketOption. 254 // Cannot be used after Bind(). 255 int multicast_time_to_live_; 256 257 // How to do source port binding, used only when UDPSocket is part of 258 // UDPClientSocket, since UDPServerSocket provides Bind. 259 DatagramSocket::BindType bind_type_; 260 261 // PRNG function for generating port numbers. 262 RandIntCallback rand_int_cb_; 263 264 // These are mutable since they're just cached copies to make 265 // GetPeerAddress/GetLocalAddress smarter. 266 mutable scoped_ptr<IPEndPoint> local_address_; 267 mutable scoped_ptr<IPEndPoint> remote_address_; 268 269 // The socket's libevent wrappers 270 base::MessageLoopForIO::FileDescriptorWatcher read_socket_watcher_; 271 base::MessageLoopForIO::FileDescriptorWatcher write_socket_watcher_; 272 273 // The corresponding watchers for reads and writes. 274 ReadWatcher read_watcher_; 275 WriteWatcher write_watcher_; 276 277 // The buffer used by InternalRead() to retry Read requests 278 scoped_refptr<IOBuffer> read_buf_; 279 int read_buf_len_; 280 IPEndPoint* recv_from_address_; 281 282 // The buffer used by InternalWrite() to retry Write requests 283 scoped_refptr<IOBuffer> write_buf_; 284 int write_buf_len_; 285 scoped_ptr<IPEndPoint> send_to_address_; 286 287 // External callback; called when read is complete. 288 CompletionCallback read_callback_; 289 290 // External callback; called when write is complete. 291 CompletionCallback write_callback_; 292 293 BoundNetLog net_log_; 294 295 DISALLOW_COPY_AND_ASSIGN(UDPSocketLibevent); 296}; 297 298} // namespace net 299 300#endif // NET_UDP_UDP_SOCKET_LIBEVENT_H_ 301