1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// A toy client, which connects to a specified port and sends QUIC
// request to that endpoint.
#ifndef NET_TOOLS_QUIC_QUIC_CLIENT_H_
#define NET_TOOLS_QUIC_QUIC_CLIENT_H_
#include <string>
#include "base/command_line.h"
#include "base/hash_tables.h"
#include "base/memory/scoped_ptr.h"
#include "net/base/ip_endpoint.h"
#include "net/quic/crypto/crypto_handshake.h"
#include "net/quic/quic_config.h"
#include "net/quic/quic_framer.h"
#include "net/quic/quic_packet_creator.h"
#include "net/tools/flip_server/epoll_server.h"
#include "net/tools/quic/quic_client_session.h"
#include "net/tools/quic/quic_reliable_client_stream.h"
namespace net {
namespace tools {
namespace test {
class QuicClientPeer;
} // namespace test
class QuicClient : public EpollCallbackInterface {
public:
QuicClient(IPEndPoint server_address, const std::string& server_hostname);
QuicClient(IPEndPoint server_address,
const std::string& server_hostname,
const QuicConfig& config);
virtual ~QuicClient();
// Initializes the client to create a connection. Should be called exactly
// once before calling StartConnect or Connect. Returns true if the
// initialization succeeds, false otherwise.
bool Initialize();
// "Connect" to the QUIC server, including performing synchronous crypto
// handshake.
bool Connect();
// Start the crypto handshake. This can be done in place of the synchronous
// Connect(), but callers are responsible for making sure the crypto handshake
// completes.
bool StartConnect();
// Returns true if the crypto handshake has yet to establish encryption.
// Returns false if encryption is active (even if the server hasn't confirmed
// the handshake) or if the connection has been closed.
bool EncryptionBeingEstablished();
// Disconnects from the QUIC server.
void Disconnect();
// Sends a request simple GET for each URL in arg, and then waits for
// each to complete.
void SendRequestsAndWaitForResponse(const CommandLine::StringVector& args);
// Returns a newly created CreateReliableClientStream, owned by the
// QuicClient.
QuicReliableClientStream* CreateReliableClientStream();
// Wait for events until the stream with the given ID is closed.
void WaitForStreamToClose(QuicStreamId id);
// Wait up to 50ms, and handle any events which occur.
// Returns true if there are any outstanding requests.
bool WaitForEvents();
// From EpollCallbackInterface
virtual void OnRegistration(
EpollServer* eps, int fd, int event_mask) OVERRIDE {}
virtual void OnModification(int fd, int event_mask) OVERRIDE {}
virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
// |fd_| can be unregistered without the client being disconnected. This
// happens in b3m QuicProber where we unregister |fd_| to feed in events to
// the client from the SelectServer.
virtual void OnUnregistration(int fd, bool replaced) OVERRIDE {}
virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {}
QuicPacketCreator::Options* options();
QuicClientSession* session() { return session_.get(); }
bool connected() const;
int packets_dropped() { return packets_dropped_; }
void set_bind_to_address(IPAddressNumber address) {
bind_to_address_ = address;
}
IPAddressNumber bind_to_address() const { return bind_to_address_; }
void set_local_port(int local_port) { local_port_ = local_port; }
int local_port() { return local_port_; }
const IPEndPoint& server_address() const { return server_address_; }
const IPEndPoint& client_address() const { return client_address_; }
EpollServer* epoll_server() { return &epoll_server_; }
int fd() { return fd_; }
// This should only be set before the initial Connect()
void set_server_hostname(const string& hostname) {
server_hostname_ = hostname;
}
private:
friend class net::tools::test::QuicClientPeer;
// Read a UDP packet and hand it to the framer.
bool ReadAndProcessPacket();
// Set of streams created (and owned) by this client
base::hash_set<QuicReliableClientStream*> streams_;
// Address of the server.
const IPEndPoint server_address_;
// Hostname of the server. This may be a DNS name or an IP address literal.
std::string server_hostname_;
// config_ and crypto_config_ contain configuration and cached state about
// servers.
QuicConfig config_;
QuicCryptoClientConfig crypto_config_;
// Address of the client if the client is connected to the server.
IPEndPoint client_address_;
// If initialized, the address to bind to.
IPAddressNumber bind_to_address_;
// Local port to bind to. Initialize to 0.
int local_port_;
// Session which manages streams.
scoped_ptr<QuicClientSession> session_;
// Listens for events on the client socket.
EpollServer epoll_server_;
// UDP socket.
int fd_;
// Tracks if the client is initialized to connect.
bool initialized_;
// If overflow_supported_ is true, this will be the number of packets dropped
// during the lifetime of the server. This may overflow if enough packets
// are dropped.
int packets_dropped_;
// True if the kernel supports SO_RXQ_OVFL, the number of packets dropped
// because the socket would otherwise overflow.
bool overflow_supported_;
DISALLOW_COPY_AND_ASSIGN(QuicClient);
};
} // namespace tools
} // namespace net
#endif // NET_TOOLS_QUIC_QUIC_CLIENT_H_
|
