Revert to old layout for refactor

protocol/src/main/java/net/runelite/protocol/handshake/HandshakeDecoder.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.handshake;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import net.runelite.protocol.api.handshake.HandshakeType;
+import net.runelite.protocol.api.handshake.LoginHandshakePacket;
+import net.runelite.protocol.api.handshake.UpdateHandshakePacket;
+
+@Slf4j
+public class HandshakeDecoder extends ByteToMessageDecoder
+{
+	@Override
+	protected void decode(ChannelHandlerContext ctx, ByteBuf buf, List<Object> out) throws Exception
+	{
+		buf.markReaderIndex();
+		byte handshakeOpcode = buf.readByte();
+
+		HandshakeType handshakeType = HandshakeType.of(handshakeOpcode);
+		if (handshakeType == null)
+		{
+			log.warn("Unknown handshake type {} from {}",
+				handshakeOpcode, ctx.channel().remoteAddress());
+			ctx.close();
+			return;
+		}
+
+		switch (handshakeType)
+		{
+			case LOGIN:
+			{
+				LoginHandshakePacket packet = new LoginHandshakePacket();
+				out.add(packet);
+				break;
+			}
+			case UPDATE:
+			{
+				if (buf.readableBytes() < 4)
+				{
+					buf.resetReaderIndex();
+					return;
+				}
+
+				int revision = buf.readInt();
+				UpdateHandshakePacket packet = new UpdateHandshakePacket(revision);
+				out.add(packet);
+				break;
+			}
+		}
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/handshake/HandshakeResponseEncoder.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.handshake;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import net.runelite.protocol.api.handshake.HandshakeResponsePacket;
+import net.runelite.protocol.api.login.HandshakeResponseType;
+
+public class HandshakeResponseEncoder extends MessageToByteEncoder<HandshakeResponsePacket>
+{
+
+	@Override
+	protected void encode(ChannelHandlerContext ctx, HandshakeResponsePacket handshakeResponse, ByteBuf out) throws Exception
+	{
+		HandshakeResponseType handshakeResponseType = handshakeResponse.getResponse();
+		out.writeByte(handshakeResponseType.getValue());
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/handshake/LoginHandshakeEncoder.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.handshake;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import net.runelite.protocol.api.handshake.HandshakeType;
+import net.runelite.protocol.api.handshake.LoginHandshakePacket;
+
+public class LoginHandshakeEncoder extends MessageToByteEncoder<LoginHandshakePacket>
+{
+	@Override
+	protected void encode(ChannelHandlerContext ctx, LoginHandshakePacket packet, ByteBuf buf) throws Exception
+	{
+		buf.writeByte(HandshakeType.LOGIN.getValue());
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/handshake/UpdateHandshakeEncoder.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.handshake;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import net.runelite.protocol.api.handshake.HandshakeType;
+import net.runelite.protocol.api.handshake.UpdateHandshakePacket;
+
+public class UpdateHandshakeEncoder extends MessageToByteEncoder<UpdateHandshakePacket>
+{
+	@Override
+	protected void encode(ChannelHandlerContext ctx, UpdateHandshakePacket packet, ByteBuf buf) throws Exception
+	{
+		buf.writeByte(HandshakeType.UPDATE.getValue());
+		buf.writeInt(packet.getRevision());
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/decoders/ArchiveRequestDecoder.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.decoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.util.List;
+import net.runelite.protocol.api.update.ArchiveRequestPacket;
+
+public class ArchiveRequestDecoder extends ByteToMessageDecoder
+{
+
+	@Override
+	protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception
+	{
+		byte opcode = in.getByte(in.readerIndex());
+		if (opcode != UpdateOpcodes.ARCHIVE_REQUEST_HIGH
+			&& opcode != UpdateOpcodes.ARCHIVE_REQUEST_LOW)
+		{
+			ctx.fireChannelRead(in.retain());
+			return;
+		}
+
+		byte priority = in.readByte();
+		int index = in.readByte() & 0xFF;
+		int archiveId = in.readShort() & 0xFFFF;
+
+		ArchiveRequestPacket archiveRequest = new ArchiveRequestPacket();
+		archiveRequest.setPriority(priority == 1);
+		archiveRequest.setIndex(index);
+		archiveRequest.setArchive(archiveId);
+		out.add(archiveRequest);
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/decoders/ArchiveResponseDecoder.java

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.decoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.util.List;
+import net.runelite.cache.fs.jagex.CompressionType;
+import net.runelite.protocol.api.update.ArchiveResponsePacket;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ArchiveResponseDecoder extends ByteToMessageDecoder
+{
+	private static final Logger logger = LoggerFactory.getLogger(ArchiveResponseDecoder.class);
+
+	private static final int CHUNK_SIZE = 512;
+
+	@Override
+	public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception
+	{
+		if (in.readableBytes() < 8)
+		{
+			return;
+		}
+
+		ByteBuf copy = in.slice();
+
+		int index = copy.readUnsignedByte();
+		int file = copy.readUnsignedShort();
+		// decompress() starts reading here
+		int compression = copy.readUnsignedByte();
+		int compressedFileSize = copy.readInt();
+
+		assert compression == CompressionType.NONE ||
+			compression == CompressionType.BZ2 ||
+			compression == CompressionType.GZ;
+
+		int size = compressedFileSize
+			+ 5 // 1 byte compresion type, 4 byte compressed size
+			+ (compression != CompressionType.NONE ? 4 : 0); // compression has leading 4 byte decompressed length
+
+		assert size > 0;
+
+		int breaks = calculateBreaks(size);
+
+		// 3 for index/file
+		if (size + 3 + breaks > in.readableBytes())
+		{
+			logger.trace("Index {} archive {}: Not enough data yet {} > {}", index, file, size + 3 + breaks, in.readableBytes());
+			return;
+		}
+
+		ByteBuf compressedData = Unpooled.buffer(size);
+
+		int totalRead = 3;
+		in.skipBytes(3); // skip index/file
+
+		for (int i = 0; i < breaks + 1; ++i)
+		{
+			int bytesInBlock = CHUNK_SIZE - (totalRead % CHUNK_SIZE);
+			int bytesToRead = Math.min(bytesInBlock, size - compressedData.writerIndex());
+
+			logger.trace("{}/{}: reading block {}/{}, read so far this block: {}, file status: {}/{}",
+				index, file,
+				(totalRead % CHUNK_SIZE), CHUNK_SIZE,
+				bytesInBlock,
+				compressedData.writerIndex(), size);
+
+			ByteBuf chunk = in.readBytes(bytesToRead);
+			compressedData.writeBytes(chunk);
+			chunk.release();
+
+			totalRead += bytesToRead;
+
+			if (i < breaks)
+			{
+				assert compressedData.writerIndex() < size;
+				int b = in.readUnsignedByte();
+				++totalRead;
+				assert b == 0xff;
+			}
+		}
+
+		assert compressedData.writerIndex() == size;
+
+		logger.trace("{}/{}: done downloading file, remaining buffer {}",
+			index, file,
+			in.readableBytes());
+
+		ArchiveResponsePacket archiveResponse = new ArchiveResponsePacket();
+		archiveResponse.setIndex(index);
+		archiveResponse.setArchive(file);
+		archiveResponse.setData(compressedData.array());
+		out.add(archiveResponse);
+
+		compressedData.release();
+	}
+
+	/**
+	 * Calculate how many breaks there are in the file stream. There are
+	 * calculateBreaks()+1 total chunks in the file stream
+	 *
+	 * File contents are sent in 512 byte chunks, with the first byte of
+	 * each chunk except for the first one being 0xff.
+	 *
+	 * The first chunk has an 8 byte header (index, file, compression,
+	 * compressed size). So, the first chunk can contain 512 - 8 bytes of
+	 * the file, and each chunk after 511 bytes.
+	 *
+	 * The 'size' parameter has the compression type and size included in
+	 * it, since they haven't been read yet by the buffer stream, as
+	 * decompress() reads it, so we use 512 - 3 (because 8-5) = 3
+	 */
+	private static int calculateBreaks(int size)
+	{
+		int initialSize = CHUNK_SIZE - 3;
+		if (size <= initialSize)
+		{
+			return 0; // First in the initial chunk, no breaks
+		}
+		int left = size - initialSize;
+
+		if (left % (CHUNK_SIZE - 1) == 0)
+		{
+			return (left / (CHUNK_SIZE - 1));
+		}
+		else
+		{
+			// / 511 because 511 bytes of the file per chunk.
+			// + 1 if there is some left over, it still needs its
+			// own chunk
+			return (left / (CHUNK_SIZE - 1)) + 1;
+		}
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/decoders/EncryptionDecoder.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.decoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.util.List;
+import net.runelite.protocol.api.update.EncryptionPacket;
+
+public class EncryptionDecoder extends ByteToMessageDecoder
+{
+
+	@Override
+	protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception
+	{
+		if (in.getByte(in.readerIndex()) != UpdateOpcodes.ENCRYPTION)
+		{
+			ctx.fireChannelRead(in.retain());
+			return;
+		}
+
+		in.readByte();
+		byte xorKey = in.readByte();
+		in.readShort(); // always 0
+
+		EncryptionPacket encryptionPacket = new EncryptionPacket();
+		encryptionPacket.setKey(xorKey);
+		out.add(encryptionPacket);
+	}
+}

protocol/src/main/java/net/runelite/protocol/update/decoders/HandshakeResponseDecoder.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.decoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.util.List;
+import net.runelite.protocol.api.handshake.HandshakeResponsePacket;
+import net.runelite.protocol.api.login.HandshakeResponseType;
+
+public class HandshakeResponseDecoder extends ByteToMessageDecoder
+{
+
+	@Override
+	protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception
+	{
+		byte response = in.readByte();
+
+		HandshakeResponsePacket handshakeResponse = new HandshakeResponsePacket();
+		handshakeResponse.setResponse(HandshakeResponseType.of(response));
+		out.add(handshakeResponse);
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/decoders/LoggedInDecoder.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.decoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.util.List;
+
+public class LoggedInDecoder extends ByteToMessageDecoder
+{
+	@Override
+	protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> list) throws Exception
+	{
+		if (in.getByte(in.readerIndex()) != UpdateOpcodes.CLIENT_LOGGED_IN)
+		{
+			ctx.fireChannelRead(in.retain());
+			return;
+		}
+
+		in.skipBytes(4);
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/decoders/LoggedOutDecoder.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.decoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.util.List;
+
+public class LoggedOutDecoder extends ByteToMessageDecoder
+{
+	@Override
+	protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> list) throws Exception
+	{
+		if (in.getByte(in.readerIndex()) != UpdateOpcodes.CLIENT_LOGGED_OUT)
+		{
+			ctx.fireChannelRead(in.retain());
+			return;
+		}
+
+		in.skipBytes(4);
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/decoders/UpdateOpcodes.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.decoders;
+
+public class UpdateOpcodes
+{
+	public static final int ARCHIVE_REQUEST_LOW = 0;
+	public static final int ARCHIVE_REQUEST_HIGH = 1;
+	public static final int CLIENT_LOGGED_IN = 2;
+	public static final int CLIENT_LOGGED_OUT = 3;
+	public static final int ENCRYPTION = 4;
+}

protocol/src/main/java/net/runelite/protocol/update/encoders/ArchiveRequestEncoder.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.encoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import net.runelite.protocol.api.update.ArchiveRequestPacket;
+
+public class ArchiveRequestEncoder extends MessageToByteEncoder<ArchiveRequestPacket>
+{
+	@Override
+	protected void encode(ChannelHandlerContext ctx, ArchiveRequestPacket archiveRequest, ByteBuf out) throws Exception
+	{
+		out.writeByte(archiveRequest.isPriority() ? 1 : 0);
+		out.writeByte(archiveRequest.getIndex());
+		out.writeShort(archiveRequest.getArchive());
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/encoders/ArchiveResponseEncoder.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.encoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import net.runelite.protocol.api.update.ArchiveResponsePacket;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ArchiveResponseEncoder extends MessageToByteEncoder<ArchiveResponsePacket>
+{
+	private static final Logger logger = LoggerFactory.getLogger(ArchiveResponseEncoder.class);
+
+	private static final int CHUNK_SIZE = 512;
+
+	@Override
+	protected void encode(ChannelHandlerContext ctx, ArchiveResponsePacket archiveResponse, ByteBuf out) throws Exception
+	{
+		// archive file header
+		// 1 byte index
+		// 2 byte archive
+		out.writeByte(archiveResponse.getIndex());
+		out.writeShort(archiveResponse.getArchive());
+
+		int pos = out.readableBytes();
+
+		// next is the compressed data which starts with compression
+		// type and length
+		ByteBuf file = Unpooled.wrappedBuffer(archiveResponse.getData());
+		// - 3 for the header
+		int chunkSize = Math.min(file.readableBytes(), CHUNK_SIZE - 3);
+
+		writeChunk(file.readBytes(chunkSize), out);
+
+		while (file.isReadable())
+		{
+			out.writeByte(0xff);
+
+			chunkSize = Math.min(file.readableBytes(), CHUNK_SIZE - 1);
+			writeChunk(file.readBytes(chunkSize), out);
+		}
+
+		int size = out.readableBytes() - pos;
+		logger.debug("Wrote index {} archive {} (size {}) in {} bytes",
+			archiveResponse.getIndex(), archiveResponse.getArchive(),
+			archiveResponse.getData().length, size);
+	}
+
+	private void writeChunk(ByteBuf chunk, ByteBuf out)
+	{
+		try
+		{
+			out.writeBytes(chunk);
+		}
+		finally
+		{
+			chunk.release();
+		}
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/encoders/EncryptionEncoder.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.encoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import net.runelite.protocol.api.update.EncryptionPacket;
+import net.runelite.protocol.update.decoders.UpdateOpcodes;
+
+public class EncryptionEncoder extends MessageToByteEncoder<EncryptionPacket>
+{
+
+	@Override
+	protected void encode(ChannelHandlerContext ctx, EncryptionPacket encryptionPacket, ByteBuf out) throws Exception
+	{
+		out.writeByte(UpdateOpcodes.ENCRYPTION);
+		out.writeByte(encryptionPacket.getKey());
+		out.writeShort(0);
+	}
+
+}

protocol/src/main/java/net/runelite/protocol/update/encoders/XorEncoder.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.encoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+
+public class XorEncoder extends MessageToByteEncoder<ByteBuf>
+{
+	private byte key;
+
+	public byte getKey()
+	{
+		return key;
+	}
+
+	public void setKey(byte key)
+	{
+		this.key = key;
+	}
+
+	@Override
+	protected void encode(ChannelHandlerContext ctx, ByteBuf msg, ByteBuf out) throws Exception
+	{
+		if (key == 0)
+		{
+			out.writeBytes(msg);
+			return;
+		}
+
+		while (msg.isReadable())
+		{
+			out.writeByte(msg.readByte() ^ key);
+		}
+	}
+
+}

protocol/src/test/java/net/runelite/protocol/update/encoders/ArchiveResponseEncoderTest.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.encoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import net.runelite.cache.fs.Container;
+import net.runelite.cache.fs.jagex.CompressionType;
+import net.runelite.protocol.update.decoders.ArchiveResponseDecoder;
+import net.runelite.protocol.api.update.ArchiveResponsePacket;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ArchiveResponseEncoderTest
+{
+	@Test
+	public void testEncode() throws Exception
+	{
+		byte[] data = new byte[1000];
+		Random random = new Random(42L);
+		random.nextBytes(data);
+
+		Container container = new Container(CompressionType.NONE, -1);
+		container.compress(data, null);
+		byte[] compressedData = container.data;
+
+		ArchiveResponsePacket archiveResponse = new ArchiveResponsePacket();
+		archiveResponse.setIndex(0);
+		archiveResponse.setArchive(1);
+		archiveResponse.setData(compressedData);
+
+		ByteBuf buf = Unpooled.buffer(1024);
+		ArchiveResponseEncoder encoder = new ArchiveResponseEncoder();
+		encoder.encode(null, archiveResponse, buf);
+
+		ArchiveResponseDecoder decoder = new ArchiveResponseDecoder();
+		List<Object> out = new ArrayList<>();
+		decoder.decode(null, buf, out);
+
+		Assert.assertEquals(1, out.size());
+		ArchiveResponsePacket response = (ArchiveResponsePacket) out.get(0);
+
+		Assert.assertEquals(archiveResponse.getIndex(), response.getIndex());
+		Assert.assertEquals(archiveResponse.getArchive(), response.getArchive());
+		Assert.assertArrayEquals(archiveResponse.getData(), response.getData());
+
+		byte[] decompressedData = Container.decompress(response.getData(), null).data;
+		Assert.assertArrayEquals(data, decompressedData);
+	}
+
+}

protocol/src/test/java/net/runelite/protocol/update/encoders/XorEncoderTest.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2016-2017, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package net.runelite.protocol.update.encoders;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class XorEncoderTest
+{
+	@Test
+	public void testEncode() throws Exception
+	{
+		ByteBuf buf = Unpooled.buffer(1);
+		buf.markWriterIndex();
+		buf.writeByte(0xff);
+
+		XorEncoder encoder = new XorEncoder();
+		encoder.setKey((byte) 0x1);
+
+		ByteBuf out = Unpooled.buffer(1);
+		encoder.encode(null, buf, out);
+
+		byte encoded = out.readByte();
+		Assert.assertEquals((Byte) (byte) 0xfe, (Byte) encoded);
+	}
+
+}