1 /*
2  * Copyright (c) Facebook, Inc. and its affiliates.
3  * All rights reserved.
4  *
5  * This source code is licensed under the BSD-style license found in the
6  * LICENSE file in the root directory of this source tree.
7  */
8 
9 #pragma once
10 
11 #include <proxygen/lib/http/codec/HTTPCodec.h>
12 #include <proxygen/lib/utils/FilterChain.h>
13 
14 namespace proxygen {
15 
16 typedef GenericFilter<HTTPCodec,
17                       HTTPCodec::Callback,
18                       &HTTPCodec::setCallback,
19                       true>
20     HTTPCodecFilter;
21 
22 /**
23  * An implementation of HTTPCodecFilter that passes through all calls. This is
24  * useful to subclass if you aren't interested in intercepting every function.
25  * See HTTPCodec.h for documentation on these methods.
26  */
27 class PassThroughHTTPCodecFilter : public HTTPCodecFilter {
28  public:
29   /**
30    * By default, the filter gets both calls and callbacks
31    */
32   explicit PassThroughHTTPCodecFilter(bool calls = true, bool callbacks = true)
HTTPCodecFilter(calls,callbacks)33       : HTTPCodecFilter(calls, callbacks) {
34   }
35 
36   // HTTPCodec::Callback methods
37   void onMessageBegin(StreamID stream, HTTPMessage* msg) override;
38 
39   void onPushMessageBegin(StreamID stream,
40                           StreamID assocStream,
41                           HTTPMessage* msg) override;
42 
43   void onExMessageBegin(StreamID stream,
44                         StreamID controlStream,
45                         bool unidirectional,
46                         HTTPMessage* msg) override;
47 
48   void onHeadersComplete(StreamID stream,
49                          std::unique_ptr<HTTPMessage> msg) override;
50 
51   void onBody(StreamID stream,
52               std::unique_ptr<folly::IOBuf> chain,
53               uint16_t padding) override;
54 
55   void onChunkHeader(StreamID stream, size_t length) override;
56 
57   void onChunkComplete(StreamID stream) override;
58 
59   void onTrailersComplete(StreamID stream,
60                           std::unique_ptr<HTTPHeaders> trailers) override;
61 
62   void onMessageComplete(StreamID stream, bool upgrade) override;
63 
64   void onFrameHeader(StreamID stream_id,
65                      uint8_t flags,
66                      uint64_t length,
67                      uint64_t type,
68                      uint16_t version = 0) override;
69 
70   void onError(StreamID stream,
71                const HTTPException& error,
72                bool newStream = false) override;
73 
74   void onAbort(StreamID stream, ErrorCode code) override;
75 
76   void onGoaway(uint64_t lastGoodStreamID,
77                 ErrorCode code,
78                 std::unique_ptr<folly::IOBuf> debugData = nullptr) override;
79 
80   void onPingRequest(uint64_t data) override;
81 
82   void onPingReply(uint64_t data) override;
83 
84   void onWindowUpdate(StreamID stream, uint32_t amount) override;
85 
86   void onSettings(const SettingsList& settings) override;
87 
88   void onSettingsAck() override;
89 
90   void onPriority(StreamID stream,
91                   const HTTPMessage::HTTP2Priority& pri) override;
92 
93   void onPriority(StreamID stream, const HTTPPriority& pri) override;
94 
95   void onPushPriority(StreamID stream, const HTTPPriority& pri) override;
96 
97   bool onNativeProtocolUpgrade(StreamID stream,
98                                CodecProtocol protocol,
99                                const std::string& protocolString,
100                                HTTPMessage& msg) override;
101 
102   void onGenerateFrameHeader(StreamID streamID,
103                              uint8_t type,
104                              uint64_t length,
105                              uint16_t version) override;
106 
107   void onCertificateRequest(uint16_t requestId,
108                             std::unique_ptr<folly::IOBuf> authRequest) override;
109 
110   void onCertificate(uint16_t certId,
111                      std::unique_ptr<folly::IOBuf> authenticator) override;
112 
113   uint32_t numOutgoingStreams() const override;
114 
115   uint32_t numIncomingStreams() const override;
116 
117   // HTTPCodec methods
118   CompressionInfo getCompressionInfo() const override;
119 
120   CodecProtocol getProtocol() const override;
121 
122   const std::string& getUserAgent() const override;
123 
124   TransportDirection getTransportDirection() const override;
125 
126   bool supportsStreamFlowControl() const override;
127 
128   bool supportsSessionFlowControl() const override;
129 
130   StreamID createStream() override;
131 
132   void setCallback(HTTPCodec::Callback* callback) override;
133 
134   bool isBusy() const override;
135 
136   void setParserPaused(bool paused) override;
137 
138   bool isParserPaused() const override;
139 
140   size_t onIngress(const folly::IOBuf& buf) override;
141 
142   void onIngressEOF() override;
143 
144   bool onIngressUpgradeMessage(const HTTPMessage& msg) override;
145 
146   bool isReusable() const override;
147 
148   bool isWaitingToDrain() const override;
149 
150   bool closeOnEgressComplete() const override;
151 
152   bool supportsParallelRequests() const override;
153 
154   bool supportsPushTransactions() const override;
155 
156   size_t generateConnectionPreface(folly::IOBufQueue& writeBuf) override;
157 
158   void generateHeader(
159       folly::IOBufQueue& writeBuf,
160       StreamID stream,
161       const HTTPMessage& msg,
162       bool eom,
163       HTTPHeaderSize* size,
164       const folly::Optional<HTTPHeaders>& extraHeaders) override;
165 
166   void generatePushPromise(folly::IOBufQueue& writeBuf,
167                            StreamID stream,
168                            const HTTPMessage& msg,
169                            StreamID assocStream,
170                            bool eom,
171                            HTTPHeaderSize* size) override;
172 
173   void generateExHeader(folly::IOBufQueue& writeBuf,
174                         StreamID stream,
175                         const HTTPMessage& msg,
176                         const HTTPCodec::ExAttributes& exAttributes,
177                         bool eom,
178                         HTTPHeaderSize* size) override;
179 
180   size_t generateBody(folly::IOBufQueue& writeBuf,
181                       StreamID stream,
182                       std::unique_ptr<folly::IOBuf> chain,
183                       folly::Optional<uint8_t> padding,
184                       bool eom) override;
185 
186   size_t generateChunkHeader(folly::IOBufQueue& writeBuf,
187                              StreamID stream,
188                              size_t length) override;
189 
190   size_t generateChunkTerminator(folly::IOBufQueue& writeBuf,
191                                  StreamID stream) override;
192 
193   size_t generateTrailers(folly::IOBufQueue& writeBuf,
194                           StreamID stream,
195                           const HTTPHeaders& trailers) override;
196 
197   size_t generateEOM(folly::IOBufQueue& writeBuf, StreamID stream) override;
198 
199   size_t generateRstStream(folly::IOBufQueue& writeBuf,
200                            StreamID stream,
201                            ErrorCode statusCode) override;
202 
203   size_t generateGoaway(
204       folly::IOBufQueue& writeBuf,
205       StreamID lastStream,
206       ErrorCode statusCode,
207       std::unique_ptr<folly::IOBuf> debugData = nullptr) override;
208 
209   size_t generatePingRequest(
210       folly::IOBufQueue& writeBuf,
211       folly::Optional<uint64_t> data = folly::none) override;
212 
213   size_t generatePingReply(folly::IOBufQueue& writeBuf, uint64_t data) override;
214 
215   size_t generateSettings(folly::IOBufQueue& writeBuf) override;
216 
217   size_t generateSettingsAck(folly::IOBufQueue& writeBuf) override;
218 
219   size_t generateWindowUpdate(folly::IOBufQueue& writeBuf,
220                               StreamID stream,
221                               uint32_t delta) override;
222 
223   size_t generatePriority(folly::IOBufQueue& writeBuf,
224                           StreamID stream,
225                           const HTTPMessage::HTTP2Priority& pri) override;
226 
227   size_t generatePriority(folly::IOBufQueue& writeBuf,
228                           StreamID streamId,
229                           HTTPPriority priority) override;
230 
231   size_t generatePushPriority(folly::IOBufQueue& writeBuf,
232                               StreamID pushId,
233                               HTTPPriority priority) override;
234 
235   size_t generateCertificateRequest(
236       folly::IOBufQueue& writeBuf,
237       uint16_t requestId,
238       std::unique_ptr<folly::IOBuf> chain) override;
239 
240   size_t generateCertificate(folly::IOBufQueue& writeBuf,
241                              uint16_t certId,
242                              std::unique_ptr<folly::IOBuf> certData) override;
243 
244   HTTPSettings* getEgressSettings() override;
245 
246   const HTTPSettings* getIngressSettings() const override;
247 
248   void setHeaderCodecStats(HeaderCodec::Stats* stats) override;
249 
250   void enableDoubleGoawayDrain() override;
251 
252   HTTPCodec::StreamID getLastIncomingStreamID() const override;
253 
254   uint32_t getDefaultWindowSize() const override;
255 
256   size_t addPriorityNodes(PriorityQueue& queue,
257                           folly::IOBufQueue& writeBuf,
258                           uint8_t maxLevel) override;
259 
260   StreamID mapPriorityToDependency(uint8_t priority) const override;
261 
262   int8_t mapDependencyToPriority(StreamID parent) const override;
263 };
264 
265 typedef FilterChain<HTTPCodec,
266                     HTTPCodec::Callback,
267                     PassThroughHTTPCodecFilter,
268                     &HTTPCodec::setCallback,
269                     true>
270     HTTPCodecFilterChain;
271 
272 } // namespace proxygen
273