0e4c073bcf
Motivation: ByteToMessageDecoder requires using an intermediate List to put results into. This intermediate list adds overhead (memory/CPU) which grows as the number of objects increases. This overhead can be avoided by directly propagating events through the ChannelPipeline via ctx.fireChannelRead(...). This also makes the semantics more clear and allows us to keep track if we need to call ctx.read() in all cases. Modifications: - Remove List from the method signature of ByteToMessageDecoder.decode(...) and decodeLast(...) - Adjust all sub-classes - Adjust unit tests - Fix javadocs. Result: Adjust ByteToMessageDecoder as noted in https://github.com/netty/netty/issues/8525.
118 lines
4.1 KiB
Java
118 lines
4.1 KiB
Java
/*
|
|
* Copyright 2016 The Netty Project
|
|
*
|
|
* The Netty Project licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
package io.netty.handler.codec.smtp;
|
|
|
|
import io.netty.buffer.ByteBuf;
|
|
import io.netty.channel.ChannelHandlerContext;
|
|
import io.netty.handler.codec.DecoderException;
|
|
import io.netty.handler.codec.LineBasedFrameDecoder;
|
|
import io.netty.util.CharsetUtil;
|
|
import io.netty.util.internal.UnstableApi;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Decoder for SMTP responses.
|
|
*/
|
|
@UnstableApi
|
|
public final class SmtpResponseDecoder extends LineBasedFrameDecoder {
|
|
|
|
private List<CharSequence> details;
|
|
|
|
/**
|
|
* Creates a new instance that enforces the given {@code maxLineLength}.
|
|
*/
|
|
public SmtpResponseDecoder(int maxLineLength) {
|
|
super(maxLineLength);
|
|
}
|
|
|
|
@Override
|
|
protected SmtpResponse decode0(ChannelHandlerContext ctx, ByteBuf buffer) throws Exception {
|
|
ByteBuf frame = (ByteBuf) super.decode0(ctx, buffer);
|
|
if (frame == null) {
|
|
// No full line received yet.
|
|
return null;
|
|
}
|
|
try {
|
|
final int readable = frame.readableBytes();
|
|
final int readerIndex = frame.readerIndex();
|
|
if (readable < 3) {
|
|
throw newDecoderException(buffer, readerIndex, readable);
|
|
}
|
|
final int code = parseCode(frame);
|
|
final int separator = frame.readByte();
|
|
final CharSequence detail = frame.isReadable() ? frame.toString(CharsetUtil.US_ASCII) : null;
|
|
|
|
List<CharSequence> details = this.details;
|
|
|
|
switch (separator) {
|
|
case ' ':
|
|
// Marks the end of a response.
|
|
this.details = null;
|
|
if (details != null) {
|
|
if (detail != null) {
|
|
details.add(detail);
|
|
}
|
|
} else {
|
|
if (detail == null) {
|
|
details = Collections.emptyList();
|
|
} else {
|
|
details = Collections.singletonList(detail);
|
|
}
|
|
}
|
|
return new DefaultSmtpResponse(code, details);
|
|
case '-':
|
|
// Multi-line response.
|
|
if (detail != null) {
|
|
if (details == null) {
|
|
// Using initial capacity as it is very unlikely that we will receive a multi-line response
|
|
// with more then 3 lines.
|
|
this.details = details = new ArrayList<>(4);
|
|
}
|
|
details.add(detail);
|
|
}
|
|
break;
|
|
default:
|
|
throw newDecoderException(buffer, readerIndex, readable);
|
|
}
|
|
} finally {
|
|
frame.release();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static DecoderException newDecoderException(ByteBuf buffer, int readerIndex, int readable) {
|
|
return new DecoderException(
|
|
"Received invalid line: '" + buffer.toString(readerIndex, readable, CharsetUtil.US_ASCII) + '\'');
|
|
}
|
|
|
|
/**
|
|
* Parses the io.netty.handler.codec.smtp code without any allocation, which is three digits.
|
|
*/
|
|
private static int parseCode(ByteBuf buffer) {
|
|
final int first = parseNumber(buffer.readByte()) * 100;
|
|
final int second = parseNumber(buffer.readByte()) * 10;
|
|
final int third = parseNumber(buffer.readByte());
|
|
return first + second + third;
|
|
}
|
|
|
|
private static int parseNumber(byte b) {
|
|
return Character.digit((char) b, 10);
|
|
}
|
|
}
|