1 /*
2 * Copyright 2014 The Netty Project
3 *
4 * The Netty Project licenses this file to you under the Apache License,
5 * version 2.0 (the "License"); you may not use this file except in compliance
6 * with the License. You may obtain a copy of the License at:
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations
14 * under the License.
15 */
16 package org.jboss.netty.handler.codec.spdy;
17
18 import org.jboss.netty.buffer.ChannelBuffer;
19 import org.jboss.netty.buffer.ChannelBuffers;
20
21 import static org.jboss.netty.handler.codec.spdy.SpdyCodecUtil.*;
22
23 public class SpdyHeaderBlockRawDecoder extends SpdyHeaderBlockDecoder {
24
25 private static final int LENGTH_FIELD_SIZE = 4;
26
27 private final int maxHeaderSize;
28
29 private State state;
30
31 private ChannelBuffer cumulation;
32
33 private int headerSize;
34 private int numHeaders;
35 private int length;
36 private String name;
37
38 private enum State {
39 READ_NUM_HEADERS,
40 READ_NAME_LENGTH,
41 READ_NAME,
42 SKIP_NAME,
43 READ_VALUE_LENGTH,
44 READ_VALUE,
45 SKIP_VALUE,
46 END_HEADER_BLOCK,
47 ERROR
48 }
49
50 public SpdyHeaderBlockRawDecoder(SpdyVersion spdyVersion, int maxHeaderSize) {
51 if (spdyVersion == null) {
52 throw new NullPointerException("spdyVersion");
53 }
54 this.maxHeaderSize = maxHeaderSize;
55 this.state = State.READ_NUM_HEADERS;
56 }
57
58 private int readLengthField(ChannelBuffer buffer) {
59 int length = getSignedInt(buffer, buffer.readerIndex());
60 buffer.skipBytes(LENGTH_FIELD_SIZE);
61 return length;
62 }
63
64 @Override
65 void decode(ChannelBuffer headerBlock, SpdyHeadersFrame frame) throws Exception {
66 if (headerBlock == null) {
67 throw new NullPointerException("headerBlock");
68 }
69 if (frame == null) {
70 throw new NullPointerException("frame");
71 }
72
73 if (cumulation == null) {
74 decodeHeaderBlock(headerBlock, frame);
75 if (headerBlock.readable()) {
76 cumulation = ChannelBuffers.dynamicBuffer(headerBlock.readableBytes());
77 cumulation.writeBytes(headerBlock);
78 }
79 } else {
80 cumulation.writeBytes(headerBlock);
81 decodeHeaderBlock(cumulation, frame);
82 if (cumulation.readable()) {
83 cumulation.discardReadBytes();
84 } else {
85 cumulation = null;
86 }
87 }
88 }
89
90 protected void decodeHeaderBlock(ChannelBuffer headerBlock, SpdyHeadersFrame frame) throws Exception {
91 int skipLength;
92 while (headerBlock.readable()) {
93 switch(state) {
94 case READ_NUM_HEADERS:
95 if (headerBlock.readableBytes() < LENGTH_FIELD_SIZE) {
96 return;
97 }
98
99 numHeaders = readLengthField(headerBlock);
100
101 if (numHeaders < 0) {
102 state = State.ERROR;
103 frame.setInvalid();
104 } else if (numHeaders == 0) {
105 state = State.END_HEADER_BLOCK;
106 } else {
107 state = State.READ_NAME_LENGTH;
108 }
109 break;
110
111 case READ_NAME_LENGTH:
112 if (headerBlock.readableBytes() < LENGTH_FIELD_SIZE) {
113 return;
114 }
115
116 length = readLengthField(headerBlock);
117
118 // Recipients of a zero-length name must issue a stream error
119 if (length <= 0) {
120 state = State.ERROR;
121 frame.setInvalid();
122 } else if (length > maxHeaderSize || headerSize > maxHeaderSize - length) {
123 headerSize = maxHeaderSize + 1;
124 state = State.SKIP_NAME;
125 frame.setTruncated();
126 } else {
127 headerSize += length;
128 state = State.READ_NAME;
129 }
130 break;
131
132 case READ_NAME:
133 if (headerBlock.readableBytes() < length) {
134 return;
135 }
136
137 byte[] nameBytes = new byte[length];
138 headerBlock.readBytes(nameBytes);
139 name = new String(nameBytes, "UTF-8");
140
141 // Check for identically named headers
142 if (frame.headers().contains(name)) {
143 state = State.ERROR;
144 frame.setInvalid();
145 } else {
146 state = State.READ_VALUE_LENGTH;
147 }
148 break;
149
150 case SKIP_NAME:
151 skipLength = Math.min(headerBlock.readableBytes(), length);
152 headerBlock.skipBytes(skipLength);
153 length -= skipLength;
154
155 if (length == 0) {
156 state = State.READ_VALUE_LENGTH;
157 }
158 break;
159
160 case READ_VALUE_LENGTH:
161 if (headerBlock.readableBytes() < LENGTH_FIELD_SIZE) {
162 return;
163 }
164
165 length = readLengthField(headerBlock);
166
167 // Recipients of illegal value fields must issue a stream error
168 if (length < 0) {
169 state = State.ERROR;
170 frame.setInvalid();
171 } else if (length == 0) {
172 if (!frame.isTruncated()) {
173 // SPDY/3 allows zero-length (empty) header values
174 frame.headers().add(name, "");
175 }
176
177 name = null;
178 if (--numHeaders == 0) {
179 state = State.END_HEADER_BLOCK;
180 } else {
181 state = State.READ_NAME_LENGTH;
182 }
183
184 } else if (length > maxHeaderSize || headerSize > maxHeaderSize - length) {
185 headerSize = maxHeaderSize + 1;
186 name = null;
187 state = State.SKIP_VALUE;
188 frame.setTruncated();
189 } else {
190 headerSize += length;
191 state = State.READ_VALUE;
192 }
193 break;
194
195 case READ_VALUE:
196 if (headerBlock.readableBytes() < length) {
197 return;
198 }
199
200 byte[] valueBytes = new byte[length];
201 headerBlock.readBytes(valueBytes);
202
203 // Add Name/Value pair to headers
204 int index = 0;
205 int offset = 0;
206
207 // Value must not start with a NULL character
208 if (valueBytes[0] == (byte) 0) {
209 state = State.ERROR;
210 frame.setInvalid();
211 break;
212 }
213
214 while (index < length) {
215 while (index < valueBytes.length && valueBytes[index] != (byte) 0) {
216 index ++;
217 }
218 if (index < valueBytes.length) {
219 // Received NULL character
220 if (index + 1 == valueBytes.length || valueBytes[index + 1] == (byte) 0) {
221 // Value field ended with a NULL character or
222 // received multiple, in-sequence NULL characters.
223 // Recipients of illegal value fields must issue a stream error
224 state = State.ERROR;
225 frame.setInvalid();
226 break;
227 }
228 }
229 String value = new String(valueBytes, offset, index - offset, "UTF-8");
230
231 try {
232 frame.headers().add(name, value);
233 } catch (IllegalArgumentException e) {
234 // Name contains NULL or non-ascii characters
235 state = State.ERROR;
236 frame.setInvalid();
237 break;
238 }
239 index ++;
240 offset = index;
241 }
242
243 name = null;
244
245 // If we broke out of the add header loop, break here
246 if (state == State.ERROR) {
247 break;
248 }
249
250 if (--numHeaders == 0) {
251 state = State.END_HEADER_BLOCK;
252 } else {
253 state = State.READ_NAME_LENGTH;
254 }
255 break;
256
257 case SKIP_VALUE:
258 skipLength = Math.min(headerBlock.readableBytes(), length);
259 headerBlock.skipBytes(skipLength);
260 length -= skipLength;
261
262 if (length == 0) {
263 if (--numHeaders == 0) {
264 state = State.END_HEADER_BLOCK;
265 } else {
266 state = State.READ_NAME_LENGTH;
267 }
268 }
269 break;
270
271 case END_HEADER_BLOCK:
272 state = State.ERROR;
273 frame.setInvalid();
274 break;
275
276 case ERROR:
277 headerBlock.skipBytes(headerBlock.readableBytes());
278 return;
279
280 default:
281 throw new Error("Shouldn't reach here.");
282 }
283 }
284 }
285
286 @Override
287 void endHeaderBlock(SpdyHeadersFrame frame) throws Exception {
288 if (state != State.END_HEADER_BLOCK) {
289 frame.setInvalid();
290 }
291
292 cumulation = null;
293
294 // Initialize header block decoding fields
295 headerSize = 0;
296 name = null;
297 state = State.READ_NUM_HEADERS;
298 }
299
300 @Override
301 void end() {
302 cumulation = null;
303 }
304 }
以上源码来自： 即时通讯网 - 即时通讯开发者社区！