1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package io.netty.handler.codec.http2;
17
18 import io.netty.buffer.ByteBuf;
19 import io.netty.buffer.ByteBufUtil;
20 import io.netty.buffer.Unpooled;
21 import io.netty.channel.Channel;
22 import io.netty.channel.ChannelHandlerContext;
23 import io.netty.channel.ChannelPromise;
24 import io.netty.channel.DefaultChannelPromise;
25 import io.netty.handler.ssl.ApplicationProtocolNames;
26 import io.netty.util.AsciiString;
27 import io.netty.util.concurrent.EventExecutor;
28
29 import static io.netty.buffer.Unpooled.directBuffer;
30 import static io.netty.buffer.Unpooled.unreleasableBuffer;
31 import static io.netty.handler.codec.http2.Http2Error.PROTOCOL_ERROR;
32 import static io.netty.handler.codec.http2.Http2Exception.connectionError;
33 import static io.netty.handler.codec.http2.Http2Exception.headerListSizeError;
34 import static io.netty.util.CharsetUtil.UTF_8;
35 import static java.lang.Math.max;
36 import static java.lang.Math.min;
37 import static java.util.concurrent.TimeUnit.MILLISECONDS;
38 import static java.util.concurrent.TimeUnit.SECONDS;
39
40
41
42
43 public final class Http2CodecUtil {
44 public static final int CONNECTION_STREAM_ID = 0;
45 public static final int HTTP_UPGRADE_STREAM_ID = 1;
46 public static final CharSequence HTTP_UPGRADE_SETTINGS_HEADER = AsciiString.cached("HTTP2-Settings");
47 public static final CharSequence HTTP_UPGRADE_PROTOCOL_NAME = "h2c";
48 public static final CharSequence TLS_UPGRADE_PROTOCOL_NAME = ApplicationProtocolNames.HTTP_2;
49
50 public static final int PING_FRAME_PAYLOAD_LENGTH = 8;
51 public static final short MAX_UNSIGNED_BYTE = 0xff;
52
53
54
55
56 public static final int MAX_PADDING = 256;
57 public static final long MAX_UNSIGNED_INT = 0xffffffffL;
58 public static final int FRAME_HEADER_LENGTH = 9;
59 public static final int SETTING_ENTRY_LENGTH = 6;
60 public static final int PRIORITY_ENTRY_LENGTH = 5;
61 public static final int INT_FIELD_LENGTH = 4;
62 public static final short MAX_WEIGHT = 256;
63 public static final short MIN_WEIGHT = 1;
64
65 private static final ByteBuf CONNECTION_PREFACE =
66 unreleasableBuffer(directBuffer(24).writeBytes("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".getBytes(UTF_8)))
67 .asReadOnly();
68
69 private static final int MAX_PADDING_LENGTH_LENGTH = 1;
70 public static final int DATA_FRAME_HEADER_LENGTH = FRAME_HEADER_LENGTH + MAX_PADDING_LENGTH_LENGTH;
71 public static final int HEADERS_FRAME_HEADER_LENGTH =
72 FRAME_HEADER_LENGTH + MAX_PADDING_LENGTH_LENGTH + INT_FIELD_LENGTH + 1;
73 public static final int PRIORITY_FRAME_LENGTH = FRAME_HEADER_LENGTH + PRIORITY_ENTRY_LENGTH;
74 public static final int RST_STREAM_FRAME_LENGTH = FRAME_HEADER_LENGTH + INT_FIELD_LENGTH;
75 public static final int PUSH_PROMISE_FRAME_HEADER_LENGTH =
76 FRAME_HEADER_LENGTH + MAX_PADDING_LENGTH_LENGTH + INT_FIELD_LENGTH;
77 public static final int GO_AWAY_FRAME_HEADER_LENGTH = FRAME_HEADER_LENGTH + 2 * INT_FIELD_LENGTH;
78 public static final int WINDOW_UPDATE_FRAME_LENGTH = FRAME_HEADER_LENGTH + INT_FIELD_LENGTH;
79 public static final int CONTINUATION_FRAME_HEADER_LENGTH = FRAME_HEADER_LENGTH;
80
81 public static final char SETTINGS_HEADER_TABLE_SIZE = 1;
82 public static final char SETTINGS_ENABLE_PUSH = 2;
83 public static final char SETTINGS_MAX_CONCURRENT_STREAMS = 3;
84 public static final char SETTINGS_INITIAL_WINDOW_SIZE = 4;
85 public static final char SETTINGS_MAX_FRAME_SIZE = 5;
86 public static final char SETTINGS_MAX_HEADER_LIST_SIZE = 6;
87 public static final char SETTINGS_ENABLE_CONNECT_PROTOCOL = 8;
88 public static final int NUM_STANDARD_SETTINGS = 7;
89
90 public static final long MAX_HEADER_TABLE_SIZE = MAX_UNSIGNED_INT;
91 public static final long MAX_CONCURRENT_STREAMS = MAX_UNSIGNED_INT;
92 public static final int MAX_INITIAL_WINDOW_SIZE = Integer.MAX_VALUE;
93 public static final int MAX_FRAME_SIZE_LOWER_BOUND = 0x4000;
94 public static final int MAX_FRAME_SIZE_UPPER_BOUND = 0xffffff;
95 public static final long MAX_HEADER_LIST_SIZE = MAX_UNSIGNED_INT;
96
97 public static final long MIN_HEADER_TABLE_SIZE = 0;
98 public static final long MIN_CONCURRENT_STREAMS = 0;
99 public static final int MIN_INITIAL_WINDOW_SIZE = 0;
100 public static final long MIN_HEADER_LIST_SIZE = 0;
101
102 public static final int DEFAULT_WINDOW_SIZE = 65535;
103 public static final short DEFAULT_PRIORITY_WEIGHT = 16;
104 public static final int DEFAULT_HEADER_TABLE_SIZE = 4096;
105
106
107
108
109
110 public static final long DEFAULT_HEADER_LIST_SIZE = 8192;
111 public static final int DEFAULT_MAX_FRAME_SIZE = MAX_FRAME_SIZE_LOWER_BOUND;
112
113
114
115
116 public static final int SMALLEST_MAX_CONCURRENT_STREAMS = 100;
117 static final int DEFAULT_MAX_RESERVED_STREAMS = SMALLEST_MAX_CONCURRENT_STREAMS;
118 static final int DEFAULT_MIN_ALLOCATION_CHUNK = 1024;
119
120
121
122
123
124
125
126
127 public static long calculateMaxHeaderListSizeGoAway(long maxHeaderListSize) {
128
129 return maxHeaderListSize + (maxHeaderListSize >>> 2);
130 }
131
132 public static final long DEFAULT_GRACEFUL_SHUTDOWN_TIMEOUT_MILLIS = MILLISECONDS.convert(30, SECONDS);
133
134 public static final int DEFAULT_MAX_QUEUED_CONTROL_FRAMES = 10000;
135
136
137
138
139
140
141
142 public static boolean isOutboundStream(boolean server, int streamId) {
143 boolean even = (streamId & 1) == 0;
144 return streamId > 0 && server == even;
145 }
146
147
148
149
150 public static boolean isStreamIdValid(int streamId) {
151 return streamId >= 0;
152 }
153
154 static boolean isStreamIdValid(int streamId, boolean server) {
155 return isStreamIdValid(streamId) && server == ((streamId & 1) == 0);
156 }
157
158
159
160
161 public static boolean isMaxFrameSizeValid(int maxFrameSize) {
162 return maxFrameSize >= MAX_FRAME_SIZE_LOWER_BOUND && maxFrameSize <= MAX_FRAME_SIZE_UPPER_BOUND;
163 }
164
165
166
167
168 public static ByteBuf connectionPrefaceBuf() {
169
170 return CONNECTION_PREFACE.retainedDuplicate();
171 }
172
173
174
175
176
177 public static Http2Exception getEmbeddedHttp2Exception(Throwable cause) {
178 while (cause != null) {
179 if (cause instanceof Http2Exception) {
180 return (Http2Exception) cause;
181 }
182 cause = cause.getCause();
183 }
184 return null;
185 }
186
187
188
189
190
191 public static ByteBuf toByteBuf(ChannelHandlerContext ctx, Throwable cause) {
192 if (cause == null || cause.getMessage() == null) {
193 return Unpooled.EMPTY_BUFFER;
194 }
195
196 return ByteBufUtil.writeUtf8(ctx.alloc(), cause.getMessage());
197 }
198
199
200
201
202 public static int readUnsignedInt(ByteBuf buf) {
203 return buf.readInt() & 0x7fffffff;
204 }
205
206
207
208
209 public static void writeFrameHeader(ByteBuf out, int payloadLength, byte type,
210 Http2Flags flags, int streamId) {
211 out.ensureWritable(FRAME_HEADER_LENGTH + payloadLength);
212 writeFrameHeaderInternal(out, payloadLength, type, flags, streamId);
213 }
214
215
216
217
218 public static int streamableBytes(StreamByteDistributor.StreamState state) {
219 return max(0, (int) min(state.pendingBytes(), state.windowSize()));
220 }
221
222
223
224
225
226
227
228
229
230 public static void headerListSizeExceeded(int streamId, long maxHeaderListSize,
231 boolean onDecode) throws Http2Exception {
232 throw headerListSizeError(streamId, PROTOCOL_ERROR, onDecode, "Header size exceeded max " +
233 "allowed size (%d)", maxHeaderListSize);
234 }
235
236
237
238
239
240
241
242
243 public static void headerListSizeExceeded(long maxHeaderListSize) throws Http2Exception {
244 throw connectionError(PROTOCOL_ERROR, "Header size exceeded max " +
245 "allowed size (%d)", maxHeaderListSize);
246 }
247
248 static void writeFrameHeaderInternal(ByteBuf out, int payloadLength, byte type,
249 Http2Flags flags, int streamId) {
250 out.writeMedium(payloadLength);
251 out.writeByte(type);
252 out.writeByte(flags.value());
253 out.writeInt(streamId);
254 }
255
256
257
258
259
260 static final class SimpleChannelPromiseAggregator extends DefaultChannelPromise {
261 private final ChannelPromise promise;
262 private int expectedCount;
263 private int doneCount;
264 private Throwable aggregateFailure;
265 private boolean doneAllocating;
266
267 SimpleChannelPromiseAggregator(ChannelPromise promise, Channel c, EventExecutor e) {
268 super(c, e);
269 assert promise != null && !promise.isDone();
270 this.promise = promise;
271 }
272
273
274
275
276
277
278 public ChannelPromise newPromise() {
279 assert !doneAllocating : "Done allocating. No more promises can be allocated.";
280 ++expectedCount;
281 return this;
282 }
283
284
285
286
287
288
289 public ChannelPromise doneAllocatingPromises() {
290 if (!doneAllocating) {
291 doneAllocating = true;
292 if (doneCount == expectedCount || expectedCount == 0) {
293 return setPromise();
294 }
295 }
296 return this;
297 }
298
299 @Override
300 public boolean tryFailure(Throwable cause) {
301 if (allowFailure()) {
302 ++doneCount;
303 setAggregateFailure(cause);
304 if (allPromisesDone()) {
305 return tryPromise();
306 }
307
308
309 return true;
310 }
311 return false;
312 }
313
314
315
316
317
318
319
320 @Override
321 public ChannelPromise setFailure(Throwable cause) {
322 if (allowFailure()) {
323 ++doneCount;
324 setAggregateFailure(cause);
325 if (allPromisesDone()) {
326 return setPromise();
327 }
328 }
329 return this;
330 }
331
332 @Override
333 public ChannelPromise setSuccess(Void result) {
334 if (awaitingPromises()) {
335 ++doneCount;
336 if (allPromisesDone()) {
337 setPromise();
338 }
339 }
340 return this;
341 }
342
343 @Override
344 public boolean trySuccess(Void result) {
345 if (awaitingPromises()) {
346 ++doneCount;
347 if (allPromisesDone()) {
348 return tryPromise();
349 }
350
351
352 return true;
353 }
354 return false;
355 }
356
357 private boolean allowFailure() {
358 return awaitingPromises() || expectedCount == 0;
359 }
360
361 private boolean awaitingPromises() {
362 return doneCount < expectedCount;
363 }
364
365 private boolean allPromisesDone() {
366 return doneCount == expectedCount && doneAllocating;
367 }
368
369 private ChannelPromise setPromise() {
370 if (aggregateFailure == null) {
371 promise.setSuccess();
372 return super.setSuccess(null);
373 } else {
374 promise.setFailure(aggregateFailure);
375 return super.setFailure(aggregateFailure);
376 }
377 }
378
379 private boolean tryPromise() {
380 if (aggregateFailure == null) {
381 promise.trySuccess();
382 return super.trySuccess(null);
383 } else {
384 promise.tryFailure(aggregateFailure);
385 return super.tryFailure(aggregateFailure);
386 }
387 }
388
389 private void setAggregateFailure(Throwable cause) {
390 if (aggregateFailure == null) {
391 aggregateFailure = cause;
392 }
393 }
394 }
395
396 public static void verifyPadding(int padding) {
397 if (padding < 0 || padding > MAX_PADDING) {
398 throw new IllegalArgumentException(String.format("Invalid padding '%d'. Padding must be between 0 and " +
399 "%d (inclusive).", padding, MAX_PADDING));
400 }
401 }
402 private Http2CodecUtil() { }
403 }