net/tools/quic/quic_client.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 // A toy client, which connects to a specified port and sends QUIC
   6 // request to that endpoint.
   7
   8 #ifndef NET_TOOLS_QUIC_QUIC_CLIENT_H_
   9 #define NET_TOOLS_QUIC_QUIC_CLIENT_H_
  10
  11 #include <string>
  12
  13 #include "base/basictypes.h"
  14 #include "base/command_line.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/strings/string_piece.h"
  17 #include "net/base/ip_endpoint.h"
  18 #include "net/quic/quic_config.h"
  19 #include "net/quic/quic_data_stream.h"
  20 #include "net/tools/balsa/balsa_headers.h"
  21 #include "net/tools/epoll_server/epoll_server.h"
  22 #include "net/tools/quic/quic_client_base.h"
  23
  24 namespace net {
  25
  26 class QuicServerId;
  27
  28 namespace tools {
  29
  30 class QuicEpollConnectionHelper;
  31
  32 namespace test {
  33 class QuicClientPeer;
  34 }  // namespace test
  35
  36 class QuicClient : public QuicClientBase,
  37                    public EpollCallbackInterface,
  38                    public QuicDataStream::Visitor {
  39  public:
  40   class ResponseListener {
  41    public:
  42     ResponseListener() {}
  43     virtual ~ResponseListener() {}
  44     virtual void OnCompleteResponse(QuicStreamId id,
  45                                     const BalsaHeaders& response_headers,
  46                                     const std::string& response_body) = 0;
  47   };
  48
  49   // The client uses these objects to keep track of any data to resend upon
  50   // receipt of a stateless reject.  Recall that the client API allows callers
  51   // to optimistically send data to the server prior to handshake-confirmation.
  52   // If the client subsequently receives a stateless reject, it must tear down
  53   // its existing session, create a new session, and resend all previously sent
  54   // data.  It uses these objects to keep track of all the sent data, and to
  55   // resend the data upon a subsequent connection.
  56   class QuicDataToResend {
  57    public:
  58     // Takes ownership of |headers|.  |headers| may be null, since it's possible
  59     // to send data without headers.
  60     QuicDataToResend(BalsaHeaders* headers, base::StringPiece body, bool fin);
  61
  62     virtual ~QuicDataToResend();
  63
  64     // Must be overridden by specific classes with the actual method for
  65     // re-sending data.
  66     virtual void Resend() = 0;
  67
  68    protected:
  69     BalsaHeaders* headers_;
  70     base::StringPiece body_;
  71     bool fin_;
  72
  73    private:
  74     DISALLOW_COPY_AND_ASSIGN(QuicDataToResend);
  75   };
  76
  77   // Create a quic client, which will have events managed by an externally owned
  78   // EpollServer.
  79   QuicClient(IPEndPoint server_address,
  80              const QuicServerId& server_id,
  81              const QuicVersionVector& supported_versions,
  82              EpollServer* epoll_server);
  83   QuicClient(IPEndPoint server_address,
  84              const QuicServerId& server_id,
  85              const QuicVersionVector& supported_versions,
  86              const QuicConfig& config,
  87              EpollServer* epoll_server);
  88
  89   ~QuicClient() override;
  90
  91   // From QuicClientBase
  92   bool Initialize() override;
  93   bool WaitForEvents() override;
  94
  95   // "Connect" to the QUIC server, including performing synchronous crypto
  96   // handshake.
  97   bool Connect();
  98
  99   // Start the crypto handshake.  This can be done in place of the synchronous
 100   // Connect(), but callers are responsible for making sure the crypto handshake
 101   // completes.
 102   void StartConnect();
 103
 104   // Disconnects from the QUIC server.
 105   void Disconnect();
 106
 107   // Sends an HTTP request and does not wait for response before returning.
 108   void SendRequest(const BalsaHeaders& headers,
 109                    base::StringPiece body,
 110                    bool fin);
 111
 112   // Sends an HTTP request and waits for response before returning.
 113   void SendRequestAndWaitForResponse(const BalsaHeaders& headers,
 114                                      base::StringPiece body,
 115                                      bool fin);
 116
 117   // Sends a request simple GET for each URL in |args|, and then waits for
 118   // each to complete.
 119   void SendRequestsAndWaitForResponse(
 120       const std::vector<std::string>& url_list);
 121
 122   // Migrate to a new socket during an active connection.
 123   bool MigrateSocket(const IPAddressNumber& new_host);
 124
 125   // From EpollCallbackInterface
 126   void OnRegistration(EpollServer* eps, int fd, int event_mask) override {}
 127   void OnModification(int fd, int event_mask) override {}
 128   void OnEvent(int fd, EpollEvent* event) override;
 129   // |fd_| can be unregistered without the client being disconnected. This
 130   // happens in b3m QuicProber where we unregister |fd_| to feed in events to
 131   // the client from the SelectServer.
 132   void OnUnregistration(int fd, bool replaced) override {}
 133   void OnShutdown(EpollServer* eps, int fd) override {}
 134
 135   // QuicDataStream::Visitor
 136   void OnClose(QuicDataStream* stream) override;
 137
 138   // If the crypto handshake has not yet been confirmed, adds the data to the
 139   // queue of data to resend if the client receives a stateless reject.
 140   // Otherwise, deletes the data.  Takes ownerership of |data_to_resend|.
 141   void MaybeAddQuicDataToResend(QuicDataToResend* data_to_resend);
 142
 143   void set_bind_to_address(IPAddressNumber address) {
 144     bind_to_address_ = address;
 145   }
 146
 147   IPAddressNumber bind_to_address() const { return bind_to_address_; }
 148
 149   void set_local_port(int local_port) { local_port_ = local_port; }
 150
 151   const IPEndPoint& server_address() const { return server_address_; }
 152
 153   const IPEndPoint& client_address() const { return client_address_; }
 154
 155   int fd() { return fd_; }
 156
 157   // Takes ownership of the listener.
 158   void set_response_listener(ResponseListener* listener) {
 159     response_listener_.reset(listener);
 160   }
 161
 162   void set_store_response(bool val) { store_response_ = val; }
 163
 164   size_t latest_response_code() const;
 165   const std::string& latest_response_headers() const;
 166   const std::string& latest_response_body() const;
 167
 168  protected:
 169   virtual QuicEpollConnectionHelper* CreateQuicConnectionHelper();
 170   virtual QuicPacketWriter* CreateQuicPacketWriter();
 171
 172   virtual int ReadPacket(char* buffer,
 173                          int buffer_len,
 174                          IPEndPoint* server_address,
 175                          IPAddressNumber* client_ip);
 176
 177   EpollServer* epoll_server() { return epoll_server_; }
 178
 179   // If the socket has been created, then unregister and close() the FD.
 180   virtual void CleanUpUDPSocket();
 181
 182  private:
 183   friend class net::tools::test::QuicClientPeer;
 184
 185   // Specific QuicClient class for storing data to resend.
 186   class ClientQuicDataToResend : public QuicDataToResend {
 187    public:
 188     // Takes ownership of |headers|.
 189     ClientQuicDataToResend(BalsaHeaders* headers,
 190                            base::StringPiece body,
 191                            bool fin,
 192                            QuicClient* client)
 193         : QuicDataToResend(headers, body, fin), client_(client) {
 194       DCHECK(headers);
 195       DCHECK(client);
 196     }
 197
 198     ~ClientQuicDataToResend() override {}
 199
 200     void Resend() override;
 201
 202    private:
 203     QuicClient* client_;
 204
 205     DISALLOW_COPY_AND_ASSIGN(ClientQuicDataToResend);
 206   };
 207
 208   // Used during initialization: creates the UDP socket FD, sets socket options,
 209   // and binds the socket to our address.
 210   bool CreateUDPSocket();
 211
 212   // Actually clean up the socket.
 213   void CleanUpUDPSocketImpl();
 214
 215   // Read a UDP packet and hand it to the framer.
 216   bool ReadAndProcessPacket();
 217
 218   // Address of the server.
 219   const IPEndPoint server_address_;
 220
 221   // Address of the client if the client is connected to the server.
 222   IPEndPoint client_address_;
 223
 224   // If initialized, the address to bind to.
 225   IPAddressNumber bind_to_address_;
 226   // Local port to bind to. Initialize to 0.
 227   int local_port_;
 228
 229   // Listens for events on the client socket.
 230   EpollServer* epoll_server_;
 231   // UDP socket.
 232   int fd_;
 233
 234   // Helper to be used by created connections.
 235   scoped_ptr<QuicEpollConnectionHelper> helper_;
 236
 237   // Listens for full responses.
 238   scoped_ptr<ResponseListener> response_listener_;
 239
 240   // Tracks if the client is initialized to connect.
 241   bool initialized_;
 242
 243   // If overflow_supported_ is true, this will be the number of packets dropped
 244   // during the lifetime of the server.
 245   QuicPacketCount packets_dropped_;
 246
 247   // True if the kernel supports SO_RXQ_OVFL, the number of packets dropped
 248   // because the socket would otherwise overflow.
 249   bool overflow_supported_;
 250
 251   // If true, store the latest response code, headers, and body.
 252   bool store_response_;
 253   // HTTP response code from most recent response.
 254   size_t latest_response_code_;
 255   // HTTP headers from most recent response.
 256   std::string latest_response_headers_;
 257   // Body of most recent response.
 258   std::string latest_response_body_;
 259
 260   // Keeps track of any data sent before the handshake.
 261   std::vector<QuicDataToResend*> data_sent_before_handshake_;
 262
 263   // Once the client receives a stateless reject, keeps track of any data that
 264   // must be resent upon a subsequent successful connection.
 265   std::vector<QuicDataToResend*> data_to_resend_on_connect_;
 266
 267   DISALLOW_COPY_AND_ASSIGN(QuicClient);
 268 };
 269
 270 }  // namespace tools
 271 }  // namespace net
 272
 273 #endif  // NET_TOOLS_QUIC_QUIC_CLIENT_H_