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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
// 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.
#ifndef NET_TOOLS_FLIP_SERVER_SPDY_INTERFACE_H_
#define NET_TOOLS_FLIP_SERVER_SPDY_INTERFACE_H_
#include <map>
#include <string>
#include <vector>
#include "base/compiler_specific.h"
#include "net/spdy/buffered_spdy_framer.h"
#include "net/spdy/spdy_protocol.h"
#include "net/tools/flip_server/balsa_headers.h"
#include "net/tools/flip_server/balsa_visitor_interface.h"
#include "net/tools/flip_server/output_ordering.h"
#include "net/tools/flip_server/sm_connection.h"
#include "net/tools/flip_server/sm_interface.h"
namespace net {
class FlipAcceptor;
class MemoryCache;
class SpdySM : public BufferedSpdyFramerVisitorInterface,
public SMInterface {
public:
SpdySM(SMConnection* connection,
SMInterface* sm_http_interface,
EpollServer* epoll_server,
MemoryCache* memory_cache,
FlipAcceptor* acceptor);
virtual ~SpdySM();
virtual void InitSMInterface(SMInterface* sm_http_interface,
int32 server_idx) OVERRIDE {}
virtual void InitSMConnection(SMConnectionPoolInterface* connection_pool,
SMInterface* sm_interface,
EpollServer* epoll_server,
int fd,
std::string server_ip,
std::string server_port,
std::string remote_ip,
bool use_ssl) OVERRIDE;
private:
virtual void set_is_request() OVERRIDE {}
SMInterface* NewConnectionInterface();
SMInterface* FindOrMakeNewSMConnectionInterface(std::string server_ip,
std::string server_port);
int SpdyHandleNewStream(SpdyStreamId stream_id,
SpdyPriority priority,
const SpdyHeaderBlock& headers,
std::string& http_data,
bool* is_https_scheme);
// BufferedSpdyFramerVisitorInterface:
virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {}
virtual void OnStreamError(SpdyStreamId stream_id,
const std::string& description) OVERRIDE {}
// Called after all the header data for SYN_STREAM control frame is received.
virtual void OnSynStream(SpdyStreamId stream_id,
SpdyStreamId associated_stream_id,
SpdyPriority priority,
uint8 credential_slot,
bool fin,
bool unidirectional,
const SpdyHeaderBlock& headers) OVERRIDE;
// Called after all the header data for SYN_REPLY control frame is received.
virtual void OnSynReply(SpdyStreamId stream_id,
bool fin,
const SpdyHeaderBlock& headers) OVERRIDE;
// Called after all the header data for HEADERS control frame is received.
virtual void OnHeaders(SpdyStreamId stream_id,
bool fin,
const SpdyHeaderBlock& headers) OVERRIDE;
// Called when data is received.
// |stream_id| The stream receiving data.
// |data| A buffer containing the data received.
// |len| The length of the data buffer.
// When the other side has finished sending data on this stream,
// this method will be called with a zero-length buffer.
virtual void OnStreamFrameData(SpdyStreamId stream_id,
const char* data,
size_t len,
bool fin) OVERRIDE;
// Called when a SETTINGS frame is received.
// |clear_persisted| True if the respective flag is set on the SETTINGS frame.
virtual void OnSettings(bool clear_persisted) OVERRIDE {}
// Called when an individual setting within a SETTINGS frame has been parsed
// and validated.
virtual void OnSetting(SpdySettingsIds id,
uint8 flags,
uint32 value) OVERRIDE {}
// Called when a PING frame has been parsed.
virtual void OnPing(uint32 unique_id) OVERRIDE {}
// Called when a RST_STREAM frame has been parsed.
virtual void OnRstStream(SpdyStreamId stream_id,
SpdyRstStreamStatus status) OVERRIDE;
// Called when a GOAWAY frame has been parsed.
virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
SpdyGoAwayStatus status) OVERRIDE {}
// Called when a WINDOW_UPDATE frame has been parsed.
virtual void OnWindowUpdate(SpdyStreamId stream_id,
uint32 delta_window_size) OVERRIDE {}
// Called when a PUSH_PROMISE frame has been parsed.
virtual void OnPushPromise(SpdyStreamId stream_id,
SpdyStreamId promised_stream_id) OVERRIDE {}
public:
virtual size_t ProcessReadInput(const char* data, size_t len) OVERRIDE;
virtual size_t ProcessWriteInput(const char* data, size_t len) OVERRIDE;
virtual bool MessageFullyRead() const OVERRIDE;
virtual void SetStreamID(uint32 stream_id) OVERRIDE {}
virtual bool Error() const OVERRIDE;
virtual const char* ErrorAsString() const OVERRIDE;
virtual void Reset() OVERRIDE {}
virtual void ResetForNewInterface(int32 server_idx) OVERRIDE;
virtual void ResetForNewConnection() OVERRIDE;
// SMInterface's Cleanup is currently only called by SMConnection after a
// protocol message as been fully read. Spdy's SMInterface does not need
// to do any cleanup at this time.
// TODO(klindsay) This method is probably not being used properly and
// some logic review and method renaming is probably in order.
virtual void Cleanup() OVERRIDE {}
// Send a settings frame
virtual int PostAcceptHook() OVERRIDE;
virtual void NewStream(uint32 stream_id,
uint32 priority,
const std::string& filename) OVERRIDE;
void AddToOutputOrder(const MemCacheIter& mci);
virtual void SendEOF(uint32 stream_id) OVERRIDE;
virtual void SendErrorNotFound(uint32 stream_id) OVERRIDE;
void SendOKResponse(uint32 stream_id, std::string* output);
virtual size_t SendSynStream(uint32 stream_id,
const BalsaHeaders& headers) OVERRIDE;
virtual size_t SendSynReply(uint32 stream_id,
const BalsaHeaders& headers) OVERRIDE;
virtual void SendDataFrame(uint32 stream_id, const char* data, int64 len,
uint32 flags, bool compress) OVERRIDE;
BufferedSpdyFramer* spdy_framer() {
return buffered_spdy_framer_;
}
static std::string forward_ip_header() { return forward_ip_header_; }
static void set_forward_ip_header(std::string value) {
forward_ip_header_ = value;
}
private:
void SendEOFImpl(uint32 stream_id);
void SendErrorNotFoundImpl(uint32 stream_id);
void SendOKResponseImpl(uint32 stream_id, std::string* output);
void KillStream(uint32 stream_id);
void CopyHeaders(SpdyHeaderBlock& dest, const BalsaHeaders& headers);
size_t SendSynStreamImpl(uint32 stream_id, const BalsaHeaders& headers);
size_t SendSynReplyImpl(uint32 stream_id, const BalsaHeaders& headers);
void SendDataFrameImpl(uint32 stream_id, const char* data, int64 len,
SpdyDataFlags flags, bool compress);
void EnqueueDataFrame(DataFrame* df);
virtual void GetOutput() OVERRIDE;
private:
BufferedSpdyFramer* buffered_spdy_framer_;
bool valid_spdy_session_; // True if we have seen valid data on this session.
// Use this to fail fast when junk is sent to our
// port.
SMConnection* connection_;
OutputList* client_output_list_;
OutputOrdering client_output_ordering_;
uint32 next_outgoing_stream_id_;
EpollServer* epoll_server_;
FlipAcceptor* acceptor_;
MemoryCache* memory_cache_;
std::vector<SMInterface*> server_interface_list;
std::vector<int32> unused_server_interface_list;
typedef std::map<uint32, SMInterface*> StreamToSmif;
StreamToSmif stream_to_smif_;
bool close_on_error_;
static std::string forward_ip_header_;
};
} // namespace net
#endif // NET_TOOLS_FLIP_SERVER_SPDY_INTERFACE_H_
|
