/* * Copyright (c) 2012 Mike Heath. All rights reserved. * * Licensed 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 cloudeventbus.codec; import cloudeventbus.Constants; import cloudeventbus.Subject; import cloudeventbus.pki.CertificateChain; import cloudeventbus.pki.CertificateStoreLoader; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.ByteToMessageDecoder; import io.netty.handler.codec.TooLongFrameException; import io.netty.util.CharsetUtil; import org.apache.commons.codec.binary.Base64; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.ByteArrayInputStream; /** * @author Mike Heath <elcapo@gmail.com> */ public class Decoder extends ByteToMessageDecoder { private static final Logger LOGGER = LoggerFactory.getLogger(Decoder.class); private final int maxMessageSize; protected Decoder() { this(Constants.DEFAULT_MAX_MESSAGE_SIZE); } protected Decoder(int maxMessageSize) { this.maxMessageSize = maxMessageSize; } @Override public Frame decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception { in.markReaderIndex(); final int frameLength = indexOf(in, Codec.DELIMITER); // Frame hasn't been fully read yet. if (frameLength < 0) { if (in.readableBytes() > maxMessageSize) { throw new TooLongFrameException("Frame exceeds maximum size"); } in.resetReaderIndex(); return null; } // Empty frame, discard and continue decoding if (frameLength == 0) { in.skipBytes(Codec.DELIMITER.length); return decode(ctx, in); } if (frameLength > maxMessageSize) { throw new TooLongFrameException("Frame exceeds maximum size"); } final String command = in.readBytes(frameLength).toString(CharsetUtil.UTF_8); in.skipBytes(Codec.DELIMITER.length); final String[] parts = command.split("\\s+"); final char frameTypeChar = parts[0].charAt(0); final FrameType frameType = FrameType.getFrameType(frameTypeChar); if (frameType == null) { throw new DecodingException("Invalid frame type " + frameTypeChar); } LOGGER.debug("Decoding frame of type {}", frameType); final int argumentsLength = parts.length - 1; switch (frameType) { case AUTH_RESPONSE: assertArgumentsLength(3, argumentsLength, "authentication response"); final CertificateChain certificates = new CertificateChain(); final byte[] rawCertificates = Base64.decodeBase64(parts[1].getBytes()); CertificateStoreLoader.load(new ByteArrayInputStream(rawCertificates), certificates); final byte[] salt = Base64.decodeBase64(parts[2]); final byte[] digitalSignature = Base64.decodeBase64(parts[3]); return new AuthenticationResponseFrame(certificates, salt, digitalSignature); case AUTHENTICATE: assertArgumentsLength(1, argumentsLength, "authentication request"); final byte[] challenge = Base64.decodeBase64(parts[1]); return new AuthenticationRequestFrame(challenge); case ERROR: if (parts.length == 0) { throw new DecodingException("Error is missing error code"); } final Integer errorNumber = Integer.valueOf(parts[1]); final ErrorFrame.Code errorCode = ErrorFrame.Code.lookupCode(errorNumber); int messageIndex = 1; messageIndex = skipWhiteSpace(messageIndex, command); while (messageIndex < command.length() && Character.isDigit(command.charAt(messageIndex))) { messageIndex++; } messageIndex = skipWhiteSpace(messageIndex, command); final String errorMessage = command.substring(messageIndex).trim(); if (errorMessage.length() > 0) { return new ErrorFrame(errorCode, errorMessage); } else { return new ErrorFrame(errorCode); } case GREETING: assertArgumentsLength(3, argumentsLength, "greeting"); final int version = Integer.valueOf(parts[1]); final String agent = parts[2]; final long id = Long.valueOf(parts[3]); return new GreetingFrame(version, agent, id); case PING: return PingFrame.PING; case PONG: return PongFrame.PONG; case PUBLISH: if (argumentsLength < 2 || argumentsLength > 3) { throw new DecodingException("Expected message frame to have 2 or 3 arguments. It has " + argumentsLength + "."); } final String messageSubject = parts[1]; final String replySubject; final Integer messageLength; if (parts.length == 3) { replySubject = null; messageLength = Integer.valueOf(parts[2]); } else { replySubject = parts[2]; messageLength = Integer.valueOf(parts[3]); } if (in.readableBytes() < messageLength + Codec.DELIMITER.length) { // If we haven't received the entire message body (plus the CRLF), wait until it arrives. in.resetReaderIndex(); return null; } final ByteBuf messageBytes = in.readBytes(messageLength); final String messageBody = new String(messageBytes.array(), CharsetUtil.UTF_8); in.skipBytes(Codec.DELIMITER.length); // Ignore the CRLF after the message body. return new PublishFrame(new Subject(messageSubject), replySubject == null ? null : new Subject(replySubject), messageBody); case SERVER_READY: return ServerReadyFrame.SERVER_READY; case SUBSCRIBE: assertArgumentsLength(1, argumentsLength, "subscribe"); return new SubscribeFrame(new Subject(parts[1])); case UNSUBSCRIBE: assertArgumentsLength(1, argumentsLength, "unsubscribe"); return new UnsubscribeFrame(new Subject(parts[1])); default: throw new DecodingException("Unknown frame type " + frameType); } } private int skipWhiteSpace(int messageIndex, String command) { while (messageIndex < command.length() && Character.isWhitespace(command.charAt(messageIndex))) { messageIndex++; } return messageIndex; } private void assertArgumentsLength(int expectedArguments, int argumentsLength, String frameName) { if (argumentsLength != expectedArguments) { throw new DecodingException("Expected " + frameName + " to have " + expectedArguments + " arguments. It has " + argumentsLength + "."); } } /** * Returns the number of bytes between the readerIndex of the haystack and * the first needle found in the haystack. -1 is returned if no needle is * found in the haystack. * <p/> * Copied from {@link io.netty.handler.codec.DelimiterBasedFrameDecoder}. */ private int indexOf(ByteBuf haystack, byte[] needle) { for (int i = haystack.readerIndex(); i < haystack.writerIndex(); i++) { int haystackIndex = i; int needleIndex; for (needleIndex = 0; needleIndex < needle.length; needleIndex++) { if (haystack.getByte(haystackIndex) != needle[needleIndex]) { break; } else { haystackIndex++; if (haystackIndex == haystack.writerIndex() && needleIndex != needle.length - 1) { return -1; } } } if (needleIndex == needle.length) { // Found the needle from the haystack! return i - haystack.readerIndex(); } } return -1; } }