diff --git a/cache-client/pom.xml b/cache-client/pom.xml new file mode 100644 index 0000000000..eb5249cb58 --- /dev/null +++ b/cache-client/pom.xml @@ -0,0 +1,71 @@ + + + + 4.0.0 + + + net.runelite + runelite-parent + 1.2.11-SNAPSHOT + + + net.runelite + cache-client + Cache Client + + + + net.runelite + cache + ${project.version} + + + net.runelite + protocol + ${project.version} + + + + junit + junit + 4.12 + test + + + org.slf4j + slf4j-simple + 1.7.12 + test + + + net.runelite + cache + ${project.version} + test-jar + test + + + diff --git a/cache/src/main/java/net/runelite/cache/client/ArchiveResponseHandler.java b/cache-client/src/main/java/net/runelite/cache/client/ArchiveResponseHandler.java similarity index 96% rename from cache/src/main/java/net/runelite/cache/client/ArchiveResponseHandler.java rename to cache-client/src/main/java/net/runelite/cache/client/ArchiveResponseHandler.java index 83b430773e..f6bffbeba1 100644 --- a/cache/src/main/java/net/runelite/cache/client/ArchiveResponseHandler.java +++ b/cache-client/src/main/java/net/runelite/cache/client/ArchiveResponseHandler.java @@ -26,7 +26,7 @@ package net.runelite.cache.client; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; -import net.runelite.cache.protocol.packets.ArchiveResponsePacket; +import net.runelite.protocol.api.update.ArchiveResponsePacket; public class ArchiveResponseHandler extends SimpleChannelInboundHandler { diff --git a/cache/src/main/java/net/runelite/cache/client/CacheClient.java b/cache-client/src/main/java/net/runelite/cache/client/CacheClient.java similarity index 94% rename from cache/src/main/java/net/runelite/cache/client/CacheClient.java rename to cache-client/src/main/java/net/runelite/cache/client/CacheClient.java index 723c029696..7e3ff136f6 100644 --- a/cache/src/main/java/net/runelite/cache/client/CacheClient.java +++ b/cache-client/src/main/java/net/runelite/cache/client/CacheClient.java @@ -49,15 +49,14 @@ import net.runelite.cache.fs.Storage; import net.runelite.cache.fs.Store; import net.runelite.cache.index.ArchiveData; import net.runelite.cache.index.IndexData; -import net.runelite.cache.protocol.decoders.HandshakeResponseDecoder; -import net.runelite.cache.protocol.encoders.ArchiveRequestEncoder; -import net.runelite.cache.protocol.encoders.EncryptionEncoder; -import net.runelite.cache.protocol.encoders.HandshakeEncoder; -import net.runelite.cache.protocol.packets.ArchiveRequestPacket; -import net.runelite.cache.protocol.packets.HandshakePacket; -import net.runelite.cache.protocol.packets.HandshakeResponseType; -import net.runelite.cache.protocol.packets.HandshakeType; +import net.runelite.protocol.update.decoders.HandshakeResponseDecoder; +import net.runelite.protocol.update.encoders.ArchiveRequestEncoder; +import net.runelite.protocol.update.encoders.EncryptionEncoder; +import net.runelite.protocol.api.update.ArchiveRequestPacket; +import net.runelite.protocol.api.login.HandshakeResponseType; import net.runelite.cache.util.Crc32; +import net.runelite.protocol.api.handshake.UpdateHandshakePacket; +import net.runelite.protocol.handshake.UpdateHandshakeEncoder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -124,7 +123,7 @@ public class CacheClient implements AutoCloseable ); p.addLast( - new HandshakeEncoder(), + new UpdateHandshakeEncoder(), new EncryptionEncoder(), new ArchiveRequestEncoder() ); @@ -138,8 +137,7 @@ public class CacheClient implements AutoCloseable public CompletableFuture handshake() { - HandshakePacket handshakePacket = new HandshakePacket(); - handshakePacket.setType(HandshakeType.ON_DEMAND); + UpdateHandshakePacket handshakePacket = new UpdateHandshakePacket(); handshakePacket.setRevision(getClientRevision()); state = ClientState.HANDSHAKING; diff --git a/cache/src/main/java/net/runelite/cache/client/CacheClientHandler.java b/cache-client/src/main/java/net/runelite/cache/client/CacheClientHandler.java similarity index 100% rename from cache/src/main/java/net/runelite/cache/client/CacheClientHandler.java rename to cache-client/src/main/java/net/runelite/cache/client/CacheClientHandler.java diff --git a/cache/src/main/java/net/runelite/cache/client/ClientState.java b/cache-client/src/main/java/net/runelite/cache/client/ClientState.java similarity index 100% rename from cache/src/main/java/net/runelite/cache/client/ClientState.java rename to cache-client/src/main/java/net/runelite/cache/client/ClientState.java diff --git a/cache/src/main/java/net/runelite/cache/client/DownloadWatcher.java b/cache-client/src/main/java/net/runelite/cache/client/DownloadWatcher.java similarity index 100% rename from cache/src/main/java/net/runelite/cache/client/DownloadWatcher.java rename to cache-client/src/main/java/net/runelite/cache/client/DownloadWatcher.java diff --git a/cache/src/main/java/net/runelite/cache/client/FileResult.java b/cache-client/src/main/java/net/runelite/cache/client/FileResult.java similarity index 100% rename from cache/src/main/java/net/runelite/cache/client/FileResult.java rename to cache-client/src/main/java/net/runelite/cache/client/FileResult.java diff --git a/cache/src/main/java/net/runelite/cache/client/HandshakeResponseHandler.java b/cache-client/src/main/java/net/runelite/cache/client/HandshakeResponseHandler.java similarity index 91% rename from cache/src/main/java/net/runelite/cache/client/HandshakeResponseHandler.java rename to cache-client/src/main/java/net/runelite/cache/client/HandshakeResponseHandler.java index 80f14c5b9e..cc3e3d0cc0 100644 --- a/cache/src/main/java/net/runelite/cache/client/HandshakeResponseHandler.java +++ b/cache-client/src/main/java/net/runelite/cache/client/HandshakeResponseHandler.java @@ -29,10 +29,10 @@ import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelPipeline; import io.netty.channel.SimpleChannelInboundHandler; import java.util.concurrent.CompletableFuture; -import net.runelite.cache.protocol.decoders.ArchiveResponseDecoder; -import net.runelite.cache.protocol.packets.EncryptionPacket; -import net.runelite.cache.protocol.packets.HandshakeResponsePacket; -import net.runelite.cache.protocol.packets.HandshakeResponseType; +import net.runelite.protocol.update.decoders.ArchiveResponseDecoder; +import net.runelite.protocol.api.update.EncryptionPacket; +import net.runelite.protocol.api.handshake.HandshakeResponsePacket; +import net.runelite.protocol.api.login.HandshakeResponseType; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/cache/src/main/java/net/runelite/cache/client/IndexInfo.java b/cache-client/src/main/java/net/runelite/cache/client/IndexInfo.java similarity index 100% rename from cache/src/main/java/net/runelite/cache/client/IndexInfo.java rename to cache-client/src/main/java/net/runelite/cache/client/IndexInfo.java diff --git a/cache/src/main/java/net/runelite/cache/client/PendingFileRequest.java b/cache-client/src/main/java/net/runelite/cache/client/PendingFileRequest.java similarity index 100% rename from cache/src/main/java/net/runelite/cache/client/PendingFileRequest.java rename to cache-client/src/main/java/net/runelite/cache/client/PendingFileRequest.java diff --git a/cache/src/test/java/net/runelite/cache/client/CacheClientTest.java b/cache-client/src/test/java/net/runelite/cache/client/CacheClientTest.java similarity index 97% rename from cache/src/test/java/net/runelite/cache/client/CacheClientTest.java rename to cache-client/src/test/java/net/runelite/cache/client/CacheClientTest.java index f17a43cc8d..f5ba5d6824 100644 --- a/cache/src/test/java/net/runelite/cache/client/CacheClientTest.java +++ b/cache-client/src/test/java/net/runelite/cache/client/CacheClientTest.java @@ -28,7 +28,7 @@ import java.io.File; import java.util.concurrent.CompletableFuture; import net.runelite.cache.CacheProperties; import net.runelite.cache.fs.Store; -import net.runelite.cache.protocol.packets.HandshakeResponseType; +import net.runelite.protocol.api.login.HandshakeResponseType; import org.junit.Assert; import org.junit.Before; import org.junit.Ignore; diff --git a/cache-server/pom.xml b/cache-server/pom.xml new file mode 100644 index 0000000000..9a55ec89bf --- /dev/null +++ b/cache-server/pom.xml @@ -0,0 +1,87 @@ + + + + 4.0.0 + + + net.runelite + runelite-parent + 1.2.11-SNAPSHOT + + + net.runelite + cache-server + Cache Server + + + 160 + + + + + net.runelite + cache + ${project.version} + + + net.runelite + protocol + ${project.version} + + + + junit + junit + 4.12 + test + + + org.slf4j + slf4j-simple + 1.7.12 + test + + + net.runelite + cache + ${project.version} + test-jar + test + + + net.runelite.rs + cache + ${cache.version} + test + + + net.runelite + cache-client + ${project.version} + test + + + diff --git a/cache/src/main/java/net/runelite/cache/server/ArchiveRequestHandler.java b/cache-server/src/main/java/net/runelite/cache/server/ArchiveRequestHandler.java similarity index 95% rename from cache/src/main/java/net/runelite/cache/server/ArchiveRequestHandler.java rename to cache-server/src/main/java/net/runelite/cache/server/ArchiveRequestHandler.java index e4ced6da04..c9807aee6f 100644 --- a/cache/src/main/java/net/runelite/cache/server/ArchiveRequestHandler.java +++ b/cache-server/src/main/java/net/runelite/cache/server/ArchiveRequestHandler.java @@ -26,7 +26,6 @@ package net.runelite.cache.server; import com.google.common.primitives.Ints; import io.netty.buffer.ByteBuf; -import io.netty.buffer.Unpooled; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import java.io.IOException; @@ -38,8 +37,8 @@ import net.runelite.cache.fs.Storage; import net.runelite.cache.fs.Store; import net.runelite.cache.fs.jagex.CompressionType; import net.runelite.cache.fs.jagex.DiskStorage; -import net.runelite.cache.protocol.packets.ArchiveRequestPacket; -import net.runelite.cache.protocol.packets.ArchiveResponsePacket; +import net.runelite.protocol.api.update.ArchiveRequestPacket; +import net.runelite.protocol.api.update.ArchiveResponsePacket; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -79,7 +78,7 @@ public class ArchiveRequestHandler extends SimpleChannelInboundHandler out) throws Exception { @@ -54,26 +51,12 @@ public class CacheFrameDecoder extends ByteToMessageDecoder switch (opcode) { - case HANDSHAKE_ON_DEMAND: - length = 5; - - if (state != ClientState.HANDSHAKING) - { - ctx.close(); - return; - } - state = ClientState.CONNECTED; - break; case ARCHIVE_REQUEST_LOW: case ARCHIVE_REQUEST_HIGH: + case CLIENT_LOGGED_IN: + case CLIENT_LOGGED_OUT: case ENCRYPTION: length = 4; - - if (state != ClientState.CONNECTED) - { - ctx.close(); - return; - } break; default: logger.debug("Unknown packet opcode from {}: {}", diff --git a/cache/src/main/java/net/runelite/cache/server/CacheServer.java b/cache-server/src/main/java/net/runelite/cache/server/CacheServer.java similarity index 100% rename from cache/src/main/java/net/runelite/cache/server/CacheServer.java rename to cache-server/src/main/java/net/runelite/cache/server/CacheServer.java diff --git a/cache/src/main/java/net/runelite/cache/server/CacheServerInitializer.java b/cache-server/src/main/java/net/runelite/cache/server/CacheServerInitializer.java similarity index 85% rename from cache/src/main/java/net/runelite/cache/server/CacheServerInitializer.java rename to cache-server/src/main/java/net/runelite/cache/server/CacheServerInitializer.java index d631072f6c..0d2c648687 100644 --- a/cache/src/main/java/net/runelite/cache/server/CacheServerInitializer.java +++ b/cache-server/src/main/java/net/runelite/cache/server/CacheServerInitializer.java @@ -24,15 +24,15 @@ */ package net.runelite.cache.server; -import net.runelite.cache.protocol.decoders.HandshakeDecoder; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelPipeline; import io.netty.channel.socket.SocketChannel; -import net.runelite.cache.protocol.decoders.ArchiveRequestDecoder; -import net.runelite.cache.protocol.decoders.EncryptionDecoder; -import net.runelite.cache.protocol.encoders.ArchiveResponseEncoder; -import net.runelite.cache.protocol.encoders.HandshakeResponseEncoder; -import net.runelite.cache.protocol.encoders.XorEncoder; +import net.runelite.protocol.update.decoders.ArchiveRequestDecoder; +import net.runelite.protocol.update.decoders.EncryptionDecoder; +import net.runelite.protocol.update.encoders.ArchiveResponseEncoder; +import net.runelite.protocol.update.encoders.XorEncoder; +import net.runelite.protocol.handshake.HandshakeDecoder; +import net.runelite.protocol.handshake.HandshakeResponseEncoder; public class CacheServerInitializer extends ChannelInitializer { @@ -49,8 +49,8 @@ public class CacheServerInitializer extends ChannelInitializer ChannelPipeline p = ch.pipeline(); p.addLast( - new CacheFrameDecoder(), new HandshakeDecoder(), + new CacheFrameDecoder(), new EncryptionDecoder(), new ArchiveRequestDecoder() ); diff --git a/cache/src/main/java/net/runelite/cache/server/EncryptionHandler.java b/cache-server/src/main/java/net/runelite/cache/server/EncryptionHandler.java similarity index 94% rename from cache/src/main/java/net/runelite/cache/server/EncryptionHandler.java rename to cache-server/src/main/java/net/runelite/cache/server/EncryptionHandler.java index f3309ce826..e176816c92 100644 --- a/cache/src/main/java/net/runelite/cache/server/EncryptionHandler.java +++ b/cache-server/src/main/java/net/runelite/cache/server/EncryptionHandler.java @@ -27,8 +27,8 @@ package net.runelite.cache.server; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelPipeline; import io.netty.channel.SimpleChannelInboundHandler; -import net.runelite.cache.protocol.encoders.XorEncoder; -import net.runelite.cache.protocol.packets.EncryptionPacket; +import net.runelite.protocol.update.encoders.XorEncoder; +import net.runelite.protocol.api.update.EncryptionPacket; public class EncryptionHandler extends SimpleChannelInboundHandler { diff --git a/cache/src/main/java/net/runelite/cache/server/HandshakeHandler.java b/cache-server/src/main/java/net/runelite/cache/server/HandshakeHandler.java similarity index 77% rename from cache/src/main/java/net/runelite/cache/server/HandshakeHandler.java rename to cache-server/src/main/java/net/runelite/cache/server/HandshakeHandler.java index 552da91d5e..acc702ede6 100644 --- a/cache/src/main/java/net/runelite/cache/server/HandshakeHandler.java +++ b/cache-server/src/main/java/net/runelite/cache/server/HandshakeHandler.java @@ -25,15 +25,16 @@ package net.runelite.cache.server; import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelPipeline; import io.netty.channel.SimpleChannelInboundHandler; -import net.runelite.cache.protocol.packets.HandshakePacket; -import net.runelite.cache.protocol.packets.HandshakeResponsePacket; -import net.runelite.cache.protocol.packets.HandshakeResponseType; -import net.runelite.cache.protocol.packets.HandshakeType; +import net.runelite.protocol.api.handshake.HandshakeResponsePacket; +import net.runelite.protocol.api.login.HandshakeResponseType; +import net.runelite.protocol.api.handshake.UpdateHandshakePacket; +import net.runelite.protocol.handshake.HandshakeDecoder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class HandshakeHandler extends SimpleChannelInboundHandler +public class HandshakeHandler extends SimpleChannelInboundHandler { private static final Logger logger = LoggerFactory.getLogger(HandshakeHandler.class); @@ -45,14 +46,9 @@ public class HandshakeHandler extends SimpleChannelInboundHandler + + org.apache.maven.plugins + maven-jar-plugin + 3.0.2 + + + + test-jar + + + + diff --git a/cache/src/main/java/net/runelite/cache/InventoryManager.java b/cache/src/main/java/net/runelite/cache/InventoryManager.java new file mode 100644 index 0000000000..772d48b1a9 --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/InventoryManager.java @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2017, Adam + * 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.cache; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import net.runelite.cache.definitions.InventoryDefinition; +import net.runelite.cache.definitions.loaders.InventoryLoader; +import net.runelite.cache.fs.Archive; +import net.runelite.cache.fs.ArchiveFiles; +import net.runelite.cache.fs.FSFile; +import net.runelite.cache.fs.Index; +import net.runelite.cache.fs.Storage; +import net.runelite.cache.fs.Store; + +public class InventoryManager +{ + private final Store store; + private final List inventories = new ArrayList<>(); + + public InventoryManager(Store store) + { + this.store = store; + } + + public void load() throws IOException + { + InventoryLoader loader = new InventoryLoader(); + + Storage storage = store.getStorage(); + Index index = store.getIndex(IndexType.CONFIGS); + Archive archive = index.getArchive(ConfigType.INV.getId()); + + byte[] archiveData = storage.loadArchive(archive); + ArchiveFiles files = archive.getFiles(archiveData); + + for (FSFile file : files.getFiles()) + { + InventoryDefinition inv = loader.load(file.getFileId(), file.getContents()); + inventories.add(inv); + } + } + + public List getInventories() + { + return Collections.unmodifiableList(inventories); + } + + public InventoryDefinition findInventory(int id) + { + for (InventoryDefinition def : inventories) + { + if (def.id == id) + { + return def; + } + } + return null; + } +} diff --git a/cache/src/main/java/net/runelite/cache/protocol/packets/ArchiveRequestPacket.java b/cache/src/main/java/net/runelite/cache/protocol/packets/ArchiveRequestPacket.java deleted file mode 100644 index 847ecb90fd..0000000000 --- a/cache/src/main/java/net/runelite/cache/protocol/packets/ArchiveRequestPacket.java +++ /dev/null @@ -1,44 +0,0 @@ -package net.runelite.cache.protocol.packets; - -public class ArchiveRequestPacket -{ - private boolean priority; - private int index; - private int archive; - - @Override - public String toString() - { - return "ArchiveRequestPacket{" + "priority=" + priority + ", index=" + index + ", archive=" + archive + '}'; - } - - public boolean isPriority() - { - return priority; - } - - public void setPriority(boolean priority) - { - this.priority = priority; - } - - public int getIndex() - { - return index; - } - - public void setIndex(int index) - { - this.index = index; - } - - public int getArchive() - { - return archive; - } - - public void setArchive(int archive) - { - this.archive = archive; - } -} diff --git a/cache/src/main/java/net/runelite/cache/protocol/packets/ArchiveResponsePacket.java b/cache/src/main/java/net/runelite/cache/protocol/packets/ArchiveResponsePacket.java deleted file mode 100644 index edc9fcbb94..0000000000 --- a/cache/src/main/java/net/runelite/cache/protocol/packets/ArchiveResponsePacket.java +++ /dev/null @@ -1,44 +0,0 @@ -package net.runelite.cache.protocol.packets; - -public class ArchiveResponsePacket -{ - private int index; - private int archive; - private byte[] data; - - @Override - public String toString() - { - return "ArchiveResponsePacket{" + "index=" + index + ", archive=" + archive + ", data=" + data + '}'; - } - - public int getIndex() - { - return index; - } - - public void setIndex(int index) - { - this.index = index; - } - - public int getArchive() - { - return archive; - } - - public void setArchive(int archive) - { - this.archive = archive; - } - - public byte[] getData() - { - return data; - } - - public void setData(byte[] data) - { - this.data = data; - } -} diff --git a/cache/src/main/java/net/runelite/cache/protocol/packets/EncryptionPacket.java b/cache/src/main/java/net/runelite/cache/protocol/packets/EncryptionPacket.java deleted file mode 100644 index 8818982236..0000000000 --- a/cache/src/main/java/net/runelite/cache/protocol/packets/EncryptionPacket.java +++ /dev/null @@ -1,24 +0,0 @@ -package net.runelite.cache.protocol.packets; - -public class EncryptionPacket -{ - public static final int OPCODE = 4; - - private byte key; - - @Override - public String toString() - { - return "EncryptionPacket{" + "key=" + key + '}'; - } - - public byte getKey() - { - return key; - } - - public void setKey(byte key) - { - this.key = key; - } -} diff --git a/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakePacket.java b/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakePacket.java deleted file mode 100644 index e25b12e3e3..0000000000 --- a/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakePacket.java +++ /dev/null @@ -1,33 +0,0 @@ -package net.runelite.cache.protocol.packets; - -public class HandshakePacket -{ - private HandshakeType type; - private int revision; - - @Override - public String toString() - { - return "HandshakePacket{" + "type=" + type + ", revision=" + revision + '}'; - } - - public HandshakeType getType() - { - return type; - } - - public void setType(HandshakeType type) - { - this.type = type; - } - - public int getRevision() - { - return revision; - } - - public void setRevision(int revision) - { - this.revision = revision; - } -} diff --git a/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeResponsePacket.java b/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeResponsePacket.java deleted file mode 100644 index 31e590b7e1..0000000000 --- a/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeResponsePacket.java +++ /dev/null @@ -1,22 +0,0 @@ -package net.runelite.cache.protocol.packets; - -public class HandshakeResponsePacket -{ - private HandshakeResponseType response; - - @Override - public String toString() - { - return "HandshakeResponsePacket{" + "response=" + response + '}'; - } - - public HandshakeResponseType getResponse() - { - return response; - } - - public void setResponse(HandshakeResponseType response) - { - this.response = response; - } -} diff --git a/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeResponseType.java b/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeResponseType.java deleted file mode 100644 index 6dc0a7a806..0000000000 --- a/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeResponseType.java +++ /dev/null @@ -1,59 +0,0 @@ -package net.runelite.cache.protocol.packets; - -public enum HandshakeResponseType -{ - RESPONSE_OK(0), - ACCOUNT_DISABLED(4), - ACCOUNT_ONLINE(5), - RESPONSE_OUTDATED(6), - WORLD_FULL(7), - SERVER_OFFLINE(8), - LIMITED_EXCEEDED(9), - BAD_SESSION_ID(10), - ACCOUNT_HIJACK(11), - MEMBERS_WORLD(12), - COULD_NOT_COMPLETE_LOGIN(13), - SERVER_BEING_UPDATED(14), - TOO_MANY_ATTEMPTS(16), - MEMBERS_ONLY_AREA(17), - ACCOUNT_LOCKED(18), - CLOSED_BETA(19), - INVALID_LOGINSERVER(20), - MALFORMED_PACKET(22), - NO_REPLY_FROM_LOGINSERVER(23), - ERR_LOADING_PROFILE(24), - UNEXPECTED_LOGINSERVER_RESPONSE(25), - IP_BANNED(26), - SERVICE_UNAVAILABLE(27), - NO_DISPLAY_NAME(31), - BILLING_ERROR(32), - ACCOUNT_INACCESSABLE(37), - VOTE_TO_PLAY(38), - NOT_ELIGIBLE(55), - NEED_AUTHENTICATOR(56), - AUTHENTICATOR_CODE_WRONG(57); - - private final byte value; - - private HandshakeResponseType(int value) - { - this.value = (byte) value; - } - - public byte getValue() - { - return value; - } - - public static HandshakeResponseType of(byte value) - { - for (HandshakeResponseType type : values()) - { - if (type.value == value) - { - return type; - } - } - return null; - } -} diff --git a/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeType.java b/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeType.java deleted file mode 100644 index 1f117d5a6d..0000000000 --- a/cache/src/main/java/net/runelite/cache/protocol/packets/HandshakeType.java +++ /dev/null @@ -1,30 +0,0 @@ -package net.runelite.cache.protocol.packets; - -public enum HandshakeType -{ - ON_DEMAND(15); - - private final byte value; - - private HandshakeType(int value) - { - this.value = (byte) value; - } - - public byte getValue() - { - return value; - } - - public static HandshakeType of(byte value) - { - for (HandshakeType type : values()) - { - if (type.value == value) - { - return type; - } - } - return null; - } -} diff --git a/http-service/pom.xml b/http-service/pom.xml index dd1cb50b90..72fea815f2 100644 --- a/http-service/pom.xml +++ b/http-service/pom.xml @@ -73,6 +73,11 @@ cache ${project.version} + + net.runelite + cache-client + ${project.version} + org.sql2o diff --git a/http-service/src/main/java/net/runelite/http/service/cache/CacheUpdater.java b/http-service/src/main/java/net/runelite/http/service/cache/CacheUpdater.java index 78b7cdb0e1..6dd30700c3 100644 --- a/http-service/src/main/java/net/runelite/http/service/cache/CacheUpdater.java +++ b/http-service/src/main/java/net/runelite/http/service/cache/CacheUpdater.java @@ -37,10 +37,10 @@ import net.runelite.cache.client.CacheClient; import net.runelite.cache.client.IndexInfo; import net.runelite.cache.fs.Archive; import net.runelite.cache.fs.Store; -import net.runelite.cache.protocol.packets.HandshakeResponseType; import net.runelite.http.api.RuneliteAPI; import net.runelite.http.service.cache.beans.CacheEntry; import net.runelite.http.service.cache.beans.IndexEntry; +import net.runelite.protocol.api.login.HandshakeResponseType; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; diff --git a/pom.xml b/pom.xml index 1fc6168e65..2d7fbb0970 100644 --- a/pom.xml +++ b/pom.xml @@ -104,6 +104,8 @@ cache + cache-client + cache-server deobfuscator model-viewer runelite-api @@ -117,6 +119,8 @@ http-api http-service runelite-proxy + protocol-api + protocol diff --git a/protocol-api/pom.xml b/protocol-api/pom.xml new file mode 100644 index 0000000000..7e7c327cd0 --- /dev/null +++ b/protocol-api/pom.xml @@ -0,0 +1,68 @@ + + + + 4.0.0 + + + net.runelite + runelite-parent + 1.2.11-SNAPSHOT + + + net.runelite + protocol-api + Protocol API + + + + net.runelite + api + ${project.version} + + + org.slf4j + slf4j-api + 1.7.12 + + + com.google.guava + guava + + + org.projectlombok + lombok + 1.16.18 + provided + + + + junit + junit + 4.12 + test + + + diff --git a/cache/src/main/java/net/runelite/cache/server/ClientState.java b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakePacket.java similarity index 94% rename from cache/src/main/java/net/runelite/cache/server/ClientState.java rename to protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakePacket.java index 088e6087ce..a81812813b 100644 --- a/cache/src/main/java/net/runelite/cache/server/ClientState.java +++ b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakePacket.java @@ -22,10 +22,9 @@ * (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.cache.server; +package net.runelite.protocol.api.handshake; -public enum ClientState +public abstract class HandshakePacket { - HANDSHAKING, - CONNECTED + } diff --git a/protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakeResponsePacket.java b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakeResponsePacket.java new file mode 100644 index 0000000000..5164e042d3 --- /dev/null +++ b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakeResponsePacket.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2017, Adam + * 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.api.handshake; + +import lombok.Data; +import net.runelite.protocol.api.login.HandshakeResponseType; + +@Data +public class HandshakeResponsePacket +{ + private HandshakeResponseType response; +} diff --git a/protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakeType.java b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakeType.java new file mode 100644 index 0000000000..6da6ac01f9 --- /dev/null +++ b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/HandshakeType.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2017, Adam + * 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.api.handshake; + +public enum HandshakeType +{ + LOGIN(14), + UPDATE(15); + + private final byte value; + + HandshakeType(int value) + { + this.value = (byte) value; + } + + public byte getValue() + { + return value; + } + + public static HandshakeType of(byte value) + { + for (HandshakeType type : values()) + { + if (type.value == value) + { + return type; + } + } + return null; + } +} diff --git a/protocol-api/src/main/java/net/runelite/protocol/api/handshake/LoginHandshakePacket.java b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/LoginHandshakePacket.java new file mode 100644 index 0000000000..4a6090504e --- /dev/null +++ b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/LoginHandshakePacket.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2017, Adam + * 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.api.handshake; + +import lombok.Data; + +@Data +public class LoginHandshakePacket extends HandshakePacket +{ + +} diff --git a/protocol-api/src/main/java/net/runelite/protocol/api/handshake/UpdateHandshakePacket.java b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/UpdateHandshakePacket.java new file mode 100644 index 0000000000..9d1b20c8f2 --- /dev/null +++ b/protocol-api/src/main/java/net/runelite/protocol/api/handshake/UpdateHandshakePacket.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2017, Adam + * 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.api.handshake; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class UpdateHandshakePacket extends HandshakePacket +{ + private int revision; +} diff --git a/protocol-api/src/main/java/net/runelite/protocol/api/login/HandshakeResponseType.java b/protocol-api/src/main/java/net/runelite/protocol/api/login/HandshakeResponseType.java new file mode 100644 index 0000000000..8ba9816c96 --- /dev/null +++ b/protocol-api/src/main/java/net/runelite/protocol/api/login/HandshakeResponseType.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2017, Adam + * 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.api.login; + +public enum HandshakeResponseType +{ + RESPONSE_OK(0), + LOGGED_IN(2), + INVALID_USERNAME_OR_PASSWORD(3), + ACCOUNT_DISABLED(4), + ACCOUNT_ONLINE(5), + RESPONSE_OUTDATED(6), + WORLD_FULL(7), + SERVER_OFFLINE(8), + LIMITED_EXCEEDED(9), + BAD_SESSION_ID(10), + ACCOUNT_HIJACK(11), + MEMBERS_WORLD(12), + COULD_NOT_COMPLETE_LOGIN(13), + SERVER_BEING_UPDATED(14), + TOO_MANY_ATTEMPTS(16), + MEMBERS_ONLY_AREA(17), + ACCOUNT_LOCKED(18), + CLOSED_BETA(19), + INVALID_LOGINSERVER(20), + PROFILE_TRANSFER(21), + MALFORMED_PACKET(22), + NO_REPLY_FROM_LOGINSERVER(23), + ERR_LOADING_PROFILE(24), + UNEXPECTED_LOGINSERVER_RESPONSE(25), + IP_BANNED(26), + SERVICE_UNAVAILABLE(27), + NO_DISPLAY_NAME(31), + BILLING_ERROR(32), + ACCOUNT_INACCESSABLE(37), + VOTE_TO_PLAY(38), + NOT_ELIGIBLE(55), + NEED_AUTHENTICATOR(56), + AUTHENTICATOR_CODE_WRONG(57); + + private final byte value; + + HandshakeResponseType(int value) + { + this.value = (byte) value; + } + + public byte getValue() + { + return value; + } + + public static HandshakeResponseType of(byte value) + { + for (HandshakeResponseType type : values()) + { + if (type.value == value) + { + return type; + } + } + return null; + } +} diff --git a/protocol-api/src/main/java/net/runelite/protocol/api/update/ArchiveRequestPacket.java b/protocol-api/src/main/java/net/runelite/protocol/api/update/ArchiveRequestPacket.java new file mode 100644 index 0000000000..fd545b8745 --- /dev/null +++ b/protocol-api/src/main/java/net/runelite/protocol/api/update/ArchiveRequestPacket.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2017, Adam + * 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.api.update; + +public class ArchiveRequestPacket +{ + private boolean priority; + private int index; + private int archive; + + @Override + public String toString() + { + return "ArchiveRequestPacket{" + "priority=" + priority + ", index=" + index + ", archive=" + archive + '}'; + } + + public boolean isPriority() + { + return priority; + } + + public void setPriority(boolean priority) + { + this.priority = priority; + } + + public int getIndex() + { + return index; + } + + public void setIndex(int index) + { + this.index = index; + } + + public int getArchive() + { + return archive; + } + + public void setArchive(int archive) + { + this.archive = archive; + } +} diff --git a/protocol-api/src/main/java/net/runelite/protocol/api/update/ArchiveResponsePacket.java b/protocol-api/src/main/java/net/runelite/protocol/api/update/ArchiveResponsePacket.java new file mode 100644 index 0000000000..1a9a0b6178 --- /dev/null +++ b/protocol-api/src/main/java/net/runelite/protocol/api/update/ArchiveResponsePacket.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2017, Adam + * 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.api.update; + +public class ArchiveResponsePacket +{ + private int index; + private int archive; + private byte[] data; + + @Override + public String toString() + { + return "ArchiveResponsePacket{" + "index=" + index + ", archive=" + archive + ", data=" + data + '}'; + } + + public int getIndex() + { + return index; + } + + public void setIndex(int index) + { + this.index = index; + } + + public int getArchive() + { + return archive; + } + + public void setArchive(int archive) + { + this.archive = archive; + } + + public byte[] getData() + { + return data; + } + + public void setData(byte[] data) + { + this.data = data; + } +} diff --git a/protocol-api/src/main/java/net/runelite/protocol/api/update/EncryptionPacket.java b/protocol-api/src/main/java/net/runelite/protocol/api/update/EncryptionPacket.java new file mode 100644 index 0000000000..dbd8ab6eb9 --- /dev/null +++ b/protocol-api/src/main/java/net/runelite/protocol/api/update/EncryptionPacket.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2017, Adam + * 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.api.update; + +import lombok.Data; + +@Data +public class EncryptionPacket +{ + private byte key; +} diff --git a/protocol/pom.xml b/protocol/pom.xml new file mode 100644 index 0000000000..dbf96b518a --- /dev/null +++ b/protocol/pom.xml @@ -0,0 +1,74 @@ + + + + 4.0.0 + + + net.runelite + runelite-parent + 1.2.11-SNAPSHOT + + + net.runelite + protocol + Protocol + + + + net.runelite + protocol-api + ${project.version} + + + net.runelite + cache + ${project.version} + + + + com.google.guava + guava + + + io.netty + netty-all + 4.1.0.Final + + + org.projectlombok + lombok + 1.16.18 + provided + + + + junit + junit + 4.12 + test + + + diff --git a/protocol/src/main/java/net/runelite/protocol/handshake/HandshakeDecoder.java b/protocol/src/main/java/net/runelite/protocol/handshake/HandshakeDecoder.java new file mode 100644 index 0000000000..b733d77041 --- /dev/null +++ b/protocol/src/main/java/net/runelite/protocol/handshake/HandshakeDecoder.java @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2017, Adam + * 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 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; + } + } + } + +} diff --git a/cache/src/main/java/net/runelite/cache/protocol/encoders/HandshakeResponseEncoder.java b/protocol/src/main/java/net/runelite/protocol/handshake/HandshakeResponseEncoder.java similarity index 91% rename from cache/src/main/java/net/runelite/cache/protocol/encoders/HandshakeResponseEncoder.java rename to protocol/src/main/java/net/runelite/protocol/handshake/HandshakeResponseEncoder.java index 48c41e42af..91f2c9f753 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/encoders/HandshakeResponseEncoder.java +++ b/protocol/src/main/java/net/runelite/protocol/handshake/HandshakeResponseEncoder.java @@ -22,13 +22,13 @@ * (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.cache.protocol.encoders; +package net.runelite.protocol.handshake; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.MessageToByteEncoder; -import net.runelite.cache.protocol.packets.HandshakeResponsePacket; -import net.runelite.cache.protocol.packets.HandshakeResponseType; +import net.runelite.protocol.api.handshake.HandshakeResponsePacket; +import net.runelite.protocol.api.login.HandshakeResponseType; public class HandshakeResponseEncoder extends MessageToByteEncoder { diff --git a/cache/src/main/java/net/runelite/cache/protocol/encoders/HandshakeEncoder.java b/protocol/src/main/java/net/runelite/protocol/handshake/LoginHandshakeEncoder.java similarity index 76% rename from cache/src/main/java/net/runelite/cache/protocol/encoders/HandshakeEncoder.java rename to protocol/src/main/java/net/runelite/protocol/handshake/LoginHandshakeEncoder.java index 316c9d85d1..54189c4ec3 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/encoders/HandshakeEncoder.java +++ b/protocol/src/main/java/net/runelite/protocol/handshake/LoginHandshakeEncoder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2017, Adam + * Copyright (c) 2017, Adam * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -22,21 +22,20 @@ * (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.cache.protocol.encoders; +package net.runelite.protocol.handshake; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.MessageToByteEncoder; -import net.runelite.cache.protocol.packets.HandshakePacket; +import net.runelite.protocol.api.handshake.HandshakeType; +import net.runelite.protocol.api.handshake.LoginHandshakePacket; -public class HandshakeEncoder extends MessageToByteEncoder +public class LoginHandshakeEncoder extends MessageToByteEncoder { - @Override - protected void encode(ChannelHandlerContext ctx, HandshakePacket handshakePacket, ByteBuf out) throws Exception + protected void encode(ChannelHandlerContext ctx, LoginHandshakePacket packet, ByteBuf buf) throws Exception { - out.writeByte(handshakePacket.getType().getValue()); - out.writeInt(handshakePacket.getRevision()); + buf.writeByte(HandshakeType.LOGIN.getValue()); } } diff --git a/protocol/src/main/java/net/runelite/protocol/handshake/UpdateHandshakeEncoder.java b/protocol/src/main/java/net/runelite/protocol/handshake/UpdateHandshakeEncoder.java new file mode 100644 index 0000000000..cb3dec90ec --- /dev/null +++ b/protocol/src/main/java/net/runelite/protocol/handshake/UpdateHandshakeEncoder.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2017, Adam + * 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 +{ + @Override + protected void encode(ChannelHandlerContext ctx, UpdateHandshakePacket packet, ByteBuf buf) throws Exception + { + buf.writeByte(HandshakeType.UPDATE.getValue()); + buf.writeInt(packet.getRevision()); + } + +} diff --git a/cache/src/main/java/net/runelite/cache/protocol/decoders/ArchiveRequestDecoder.java b/protocol/src/main/java/net/runelite/protocol/update/decoders/ArchiveRequestDecoder.java similarity index 88% rename from cache/src/main/java/net/runelite/cache/protocol/decoders/ArchiveRequestDecoder.java rename to protocol/src/main/java/net/runelite/protocol/update/decoders/ArchiveRequestDecoder.java index 18feef9076..449f8cf3b7 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/decoders/ArchiveRequestDecoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/decoders/ArchiveRequestDecoder.java @@ -22,14 +22,13 @@ * (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.cache.protocol.decoders; +package net.runelite.protocol.update.decoders; -import net.runelite.cache.server.CacheFrameDecoder; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.ByteToMessageDecoder; import java.util.List; -import net.runelite.cache.protocol.packets.ArchiveRequestPacket; +import net.runelite.protocol.api.update.ArchiveRequestPacket; public class ArchiveRequestDecoder extends ByteToMessageDecoder { @@ -38,8 +37,8 @@ public class ArchiveRequestDecoder extends ByteToMessageDecoder protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception { byte opcode = in.getByte(in.readerIndex()); - if (opcode != CacheFrameDecoder.ARCHIVE_REQUEST_HIGH - && opcode != CacheFrameDecoder.ARCHIVE_REQUEST_LOW) + if (opcode != UpdateOpcodes.ARCHIVE_REQUEST_HIGH + && opcode != UpdateOpcodes.ARCHIVE_REQUEST_LOW) { ctx.fireChannelRead(in.retain()); return; diff --git a/cache/src/main/java/net/runelite/cache/protocol/decoders/ArchiveResponseDecoder.java b/protocol/src/main/java/net/runelite/protocol/update/decoders/ArchiveResponseDecoder.java similarity index 97% rename from cache/src/main/java/net/runelite/cache/protocol/decoders/ArchiveResponseDecoder.java rename to protocol/src/main/java/net/runelite/protocol/update/decoders/ArchiveResponseDecoder.java index b5bfb5f0d6..cf08e2e61d 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/decoders/ArchiveResponseDecoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/decoders/ArchiveResponseDecoder.java @@ -22,7 +22,7 @@ * (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.cache.protocol.decoders; +package net.runelite.protocol.update.decoders; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; @@ -30,7 +30,7 @@ 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.cache.protocol.packets.ArchiveResponsePacket; +import net.runelite.protocol.api.update.ArchiveResponsePacket; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/cache/src/main/java/net/runelite/cache/protocol/decoders/EncryptionDecoder.java b/protocol/src/main/java/net/runelite/protocol/update/decoders/EncryptionDecoder.java similarity index 89% rename from cache/src/main/java/net/runelite/cache/protocol/decoders/EncryptionDecoder.java rename to protocol/src/main/java/net/runelite/protocol/update/decoders/EncryptionDecoder.java index 4667822246..2f13f5559c 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/decoders/EncryptionDecoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/decoders/EncryptionDecoder.java @@ -22,14 +22,13 @@ * (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.cache.protocol.decoders; +package net.runelite.protocol.update.decoders; -import net.runelite.cache.server.CacheFrameDecoder; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.ByteToMessageDecoder; import java.util.List; -import net.runelite.cache.protocol.packets.EncryptionPacket; +import net.runelite.protocol.api.update.EncryptionPacket; public class EncryptionDecoder extends ByteToMessageDecoder { @@ -37,7 +36,7 @@ public class EncryptionDecoder extends ByteToMessageDecoder @Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception { - if (in.getByte(in.readerIndex()) != CacheFrameDecoder.ENCRYPTION) + if (in.getByte(in.readerIndex()) != UpdateOpcodes.ENCRYPTION) { ctx.fireChannelRead(in.retain()); return; diff --git a/cache/src/main/java/net/runelite/cache/protocol/decoders/HandshakeResponseDecoder.java b/protocol/src/main/java/net/runelite/protocol/update/decoders/HandshakeResponseDecoder.java similarity index 89% rename from cache/src/main/java/net/runelite/cache/protocol/decoders/HandshakeResponseDecoder.java rename to protocol/src/main/java/net/runelite/protocol/update/decoders/HandshakeResponseDecoder.java index 66633b99c9..bcadbb6a7a 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/decoders/HandshakeResponseDecoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/decoders/HandshakeResponseDecoder.java @@ -22,14 +22,14 @@ * (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.cache.protocol.decoders; +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.cache.protocol.packets.HandshakeResponsePacket; -import net.runelite.cache.protocol.packets.HandshakeResponseType; +import net.runelite.protocol.api.handshake.HandshakeResponsePacket; +import net.runelite.protocol.api.login.HandshakeResponseType; public class HandshakeResponseDecoder extends ByteToMessageDecoder { @@ -37,11 +37,6 @@ public class HandshakeResponseDecoder extends ByteToMessageDecoder @Override protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception { - if (in.readableBytes() < 1) - { - return; - } - byte response = in.readByte(); HandshakeResponsePacket handshakeResponse = new HandshakeResponsePacket(); diff --git a/cache/src/main/java/net/runelite/cache/protocol/decoders/HandshakeDecoder.java b/protocol/src/main/java/net/runelite/protocol/update/decoders/LoggedInDecoder.java similarity index 70% rename from cache/src/main/java/net/runelite/cache/protocol/decoders/HandshakeDecoder.java rename to protocol/src/main/java/net/runelite/protocol/update/decoders/LoggedInDecoder.java index f484b98001..d21ec96978 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/decoders/HandshakeDecoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/decoders/LoggedInDecoder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2017, Adam + * Copyright (c) 2017, Adam * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -22,35 +22,25 @@ * (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.cache.protocol.decoders; +package net.runelite.protocol.update.decoders; -import net.runelite.cache.server.CacheFrameDecoder; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.ByteToMessageDecoder; import java.util.List; -import net.runelite.cache.protocol.packets.HandshakePacket; -import net.runelite.cache.protocol.packets.HandshakeType; -public class HandshakeDecoder extends ByteToMessageDecoder +public class LoggedInDecoder extends ByteToMessageDecoder { - @Override - protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception + protected void decode(ChannelHandlerContext ctx, ByteBuf in, List list) throws Exception { - if (in.getByte(in.readerIndex()) != CacheFrameDecoder.HANDSHAKE_ON_DEMAND) + if (in.getByte(in.readerIndex()) != UpdateOpcodes.CLIENT_LOGGED_IN) { ctx.fireChannelRead(in.retain()); return; } - byte type = in.readByte(); - int revision = in.readInt(); - - HandshakePacket handshakePacket = new HandshakePacket(); - handshakePacket.setType(HandshakeType.of(type)); - handshakePacket.setRevision(revision); - out.add(handshakePacket); + in.skipBytes(4); } } diff --git a/protocol/src/main/java/net/runelite/protocol/update/decoders/LoggedOutDecoder.java b/protocol/src/main/java/net/runelite/protocol/update/decoders/LoggedOutDecoder.java new file mode 100644 index 0000000000..4fb1ced6df --- /dev/null +++ b/protocol/src/main/java/net/runelite/protocol/update/decoders/LoggedOutDecoder.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2017, Adam + * 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 list) throws Exception + { + if (in.getByte(in.readerIndex()) != UpdateOpcodes.CLIENT_LOGGED_OUT) + { + ctx.fireChannelRead(in.retain()); + return; + } + + in.skipBytes(4); + } + +} diff --git a/protocol/src/main/java/net/runelite/protocol/update/decoders/UpdateOpcodes.java b/protocol/src/main/java/net/runelite/protocol/update/decoders/UpdateOpcodes.java new file mode 100644 index 0000000000..46df56aa0d --- /dev/null +++ b/protocol/src/main/java/net/runelite/protocol/update/decoders/UpdateOpcodes.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2017, Adam + * 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; +} diff --git a/cache/src/main/java/net/runelite/cache/protocol/encoders/ArchiveRequestEncoder.java b/protocol/src/main/java/net/runelite/protocol/update/encoders/ArchiveRequestEncoder.java similarity index 94% rename from cache/src/main/java/net/runelite/cache/protocol/encoders/ArchiveRequestEncoder.java rename to protocol/src/main/java/net/runelite/protocol/update/encoders/ArchiveRequestEncoder.java index 57341f4fa4..13ae829ccd 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/encoders/ArchiveRequestEncoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/encoders/ArchiveRequestEncoder.java @@ -22,16 +22,15 @@ * (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.cache.protocol.encoders; +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.cache.protocol.packets.ArchiveRequestPacket; +import net.runelite.protocol.api.update.ArchiveRequestPacket; public class ArchiveRequestEncoder extends MessageToByteEncoder { - @Override protected void encode(ChannelHandlerContext ctx, ArchiveRequestPacket archiveRequest, ByteBuf out) throws Exception { diff --git a/cache/src/main/java/net/runelite/cache/protocol/encoders/ArchiveResponseEncoder.java b/protocol/src/main/java/net/runelite/protocol/update/encoders/ArchiveResponseEncoder.java similarity index 96% rename from cache/src/main/java/net/runelite/cache/protocol/encoders/ArchiveResponseEncoder.java rename to protocol/src/main/java/net/runelite/protocol/update/encoders/ArchiveResponseEncoder.java index 64a2f6c529..712a9a7767 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/encoders/ArchiveResponseEncoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/encoders/ArchiveResponseEncoder.java @@ -22,13 +22,13 @@ * (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.cache.protocol.encoders; +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.cache.protocol.packets.ArchiveResponsePacket; +import net.runelite.protocol.api.update.ArchiveResponsePacket; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/cache/src/main/java/net/runelite/cache/protocol/encoders/EncryptionEncoder.java b/protocol/src/main/java/net/runelite/protocol/update/encoders/EncryptionEncoder.java similarity index 89% rename from cache/src/main/java/net/runelite/cache/protocol/encoders/EncryptionEncoder.java rename to protocol/src/main/java/net/runelite/protocol/update/encoders/EncryptionEncoder.java index aba9406c9b..8b686358fa 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/encoders/EncryptionEncoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/encoders/EncryptionEncoder.java @@ -22,12 +22,13 @@ * (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.cache.protocol.encoders; +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.cache.protocol.packets.EncryptionPacket; +import net.runelite.protocol.api.update.EncryptionPacket; +import net.runelite.protocol.update.decoders.UpdateOpcodes; public class EncryptionEncoder extends MessageToByteEncoder { @@ -35,7 +36,7 @@ public class EncryptionEncoder extends MessageToByteEncoder @Override protected void encode(ChannelHandlerContext ctx, EncryptionPacket encryptionPacket, ByteBuf out) throws Exception { - out.writeByte(EncryptionPacket.OPCODE); + out.writeByte(UpdateOpcodes.ENCRYPTION); out.writeByte(encryptionPacket.getKey()); out.writeShort(0); } diff --git a/cache/src/main/java/net/runelite/cache/protocol/encoders/XorEncoder.java b/protocol/src/main/java/net/runelite/protocol/update/encoders/XorEncoder.java similarity index 97% rename from cache/src/main/java/net/runelite/cache/protocol/encoders/XorEncoder.java rename to protocol/src/main/java/net/runelite/protocol/update/encoders/XorEncoder.java index 13b9d311d2..0d86f99f47 100644 --- a/cache/src/main/java/net/runelite/cache/protocol/encoders/XorEncoder.java +++ b/protocol/src/main/java/net/runelite/protocol/update/encoders/XorEncoder.java @@ -22,7 +22,7 @@ * (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.cache.protocol.encoders; +package net.runelite.protocol.update.encoders; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; diff --git a/cache/src/test/java/net/runelite/cache/protocol/encoders/ArchiveResponseEncoderTest.java b/protocol/src/test/java/net/runelite/protocol/update/encoders/ArchiveResponseEncoderTest.java similarity index 87% rename from cache/src/test/java/net/runelite/cache/protocol/encoders/ArchiveResponseEncoderTest.java rename to protocol/src/test/java/net/runelite/protocol/update/encoders/ArchiveResponseEncoderTest.java index 290ed2511b..8cf508c834 100644 --- a/cache/src/test/java/net/runelite/cache/protocol/encoders/ArchiveResponseEncoderTest.java +++ b/protocol/src/test/java/net/runelite/protocol/update/encoders/ArchiveResponseEncoderTest.java @@ -22,7 +22,7 @@ * (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.cache.protocol.encoders; +package net.runelite.protocol.update.encoders; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; @@ -31,9 +31,8 @@ import java.util.List; import java.util.Random; import net.runelite.cache.fs.Container; import net.runelite.cache.fs.jagex.CompressionType; -import net.runelite.cache.fs.jagex.DataFile; -import net.runelite.cache.protocol.decoders.ArchiveResponseDecoder; -import net.runelite.cache.protocol.packets.ArchiveResponsePacket; +import net.runelite.protocol.update.decoders.ArchiveResponseDecoder; +import net.runelite.protocol.api.update.ArchiveResponsePacket; import org.junit.Assert; import org.junit.Test; @@ -46,9 +45,9 @@ public class ArchiveResponseEncoderTest Random random = new Random(42L); random.nextBytes(data); - Container container =new Container(CompressionType.NONE, -1); + Container container = new Container(CompressionType.NONE, -1); container.compress(data, null); - byte[] compressedData = container.data;//DataFile.compress(data, CompressionType.NONE, -1, null); + byte[] compressedData = container.data; ArchiveResponsePacket archiveResponse = new ArchiveResponsePacket(); archiveResponse.setIndex(0); diff --git a/cache/src/test/java/net/runelite/cache/protocol/encoders/XorEncoderTest.java b/protocol/src/test/java/net/runelite/protocol/update/encoders/XorEncoderTest.java similarity index 97% rename from cache/src/test/java/net/runelite/cache/protocol/encoders/XorEncoderTest.java rename to protocol/src/test/java/net/runelite/protocol/update/encoders/XorEncoderTest.java index 53612ac78f..0b22ed87d8 100644 --- a/cache/src/test/java/net/runelite/cache/protocol/encoders/XorEncoderTest.java +++ b/protocol/src/test/java/net/runelite/protocol/update/encoders/XorEncoderTest.java @@ -22,7 +22,7 @@ * (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.cache.protocol.encoders; +package net.runelite.protocol.update.encoders; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled;