forked from 2009Scape/Server
518 lines
16 KiB
Java
518 lines
16 KiB
Java
package org.runite.client;
|
|
|
|
import kotlin.text.Charsets;
|
|
import org.rs09.client.Linkable;
|
|
import org.rs09.client.config.GameConfig;
|
|
import org.rs09.client.util.ByteArrayPool;
|
|
import org.rs09.client.util.CRC;
|
|
|
|
import java.math.BigInteger;
|
|
import java.util.Objects;
|
|
|
|
public class DataBuffer extends Linkable {
|
|
|
|
public byte[] buffer;
|
|
public int index;
|
|
|
|
public DataBuffer(int capacity) {
|
|
this.buffer = ByteArrayPool.INSTANCE.getByteArray(capacity);
|
|
this.index = 0;
|
|
}
|
|
public DataBuffer(byte[] buffer) {
|
|
this.index = 0;
|
|
this.buffer = buffer;
|
|
}
|
|
|
|
public final int readUnsignedShort() {
|
|
this.index += 2;
|
|
return (this.buffer[-2 + this.index] << 8 & 0xff00) + (this.buffer[-1 + this.index] & 255);
|
|
}
|
|
|
|
public final void writeInt(int value) {
|
|
this.buffer[this.index++] = (byte) (value >> 24);
|
|
this.buffer[this.index++] = (byte) (value >> 16);
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
this.buffer[this.index++] = (byte) value;
|
|
}
|
|
|
|
final void writeLong(long value) {
|
|
this.buffer[this.index++] = (byte) ((int) (value >> 56));
|
|
this.buffer[this.index++] = (byte) ((int) (value >> 48));
|
|
this.buffer[this.index++] = (byte) ((int) (value >> 40));
|
|
this.buffer[this.index++] = (byte) ((int) (value >> 32));
|
|
this.buffer[this.index++] = (byte) ((int) (value >> 24));
|
|
this.buffer[this.index++] = (byte) ((int) (value >> 16));
|
|
this.buffer[this.index++] = (byte) ((int) (value >> 8));
|
|
this.buffer[this.index++] = (byte) ((int) value);
|
|
}
|
|
|
|
// TODO Rename / refactor
|
|
final void method739(int var2, long var3) {
|
|
--var2;
|
|
if (var2 >= 0 && var2 <= 7) {
|
|
for (int var5 = var2 * 8; 0 <= var5; var5 -= 8) {
|
|
this.buffer[this.index++] = (byte) ((int) (var3 >> var5));
|
|
}
|
|
|
|
} else {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
// TODO Rename / refactor
|
|
final int method741() {
|
|
byte var2 = this.buffer[this.index++];
|
|
|
|
int var3;
|
|
for (var3 = 0; 0 > var2; var2 = this.buffer[this.index++]) {
|
|
var3 = (127 & var2 | var3) << 7;
|
|
}
|
|
|
|
return var2 | var3;
|
|
}
|
|
|
|
// TODO Rename / refactor
|
|
final void method742(int var2) {
|
|
this.buffer[this.index + -var2 - 4] = (byte) (var2 >> 24);
|
|
this.buffer[this.index + -var2 - 3] = (byte) (var2 >> 16);
|
|
this.buffer[this.index + -var2 - 2] = (byte) (var2 >> 8);
|
|
this.buffer[this.index + -var2 - 1] = (byte) var2;
|
|
}
|
|
|
|
final void write128Byte(int value) {
|
|
this.buffer[this.index++] = (byte) (128 - value);
|
|
}
|
|
|
|
// TODO Rename / refactor
|
|
public final void writeString(RSString var2) {
|
|
this.index += var2.method1580(this.buffer, this.index, var2.length());
|
|
this.buffer[this.index++] = 0;
|
|
}
|
|
|
|
public final void writeString(String string) {
|
|
byte[] bytes = string.getBytes(Charsets.ISO_8859_1);
|
|
System.arraycopy(bytes, 0, buffer, index, bytes.length);
|
|
index += bytes.length;
|
|
buffer[index++] = 0;
|
|
}
|
|
|
|
final int readSignedShort128() {
|
|
this.index += 2;
|
|
int value = ((this.buffer[this.index - 2] & 0xff) << 8) +
|
|
(this.buffer[this.index - 1] - 128 & 0xff);
|
|
|
|
if (value > 32767) {
|
|
value -= 65536;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public final int readInt() {
|
|
this.index += 4;
|
|
return ((this.buffer[this.index - 4] & 0xff) << 24) +
|
|
((this.buffer[this.index - 3] & 0xff) << 16) +
|
|
((this.buffer[this.index - 2] & 0xff) << 8) +
|
|
(this.buffer[this.index - 1] & 255);
|
|
}
|
|
|
|
final byte readSigned128Byte() {
|
|
return (byte) (128 - this.buffer[this.index++]);
|
|
}
|
|
|
|
// TODO Refactor / rename method
|
|
final RSString method750() {
|
|
if (this.buffer[this.index] == 0) {
|
|
this.index++;
|
|
return null;
|
|
} else {
|
|
return this.readString();
|
|
}
|
|
}
|
|
|
|
final int readUnsignedByte128() {
|
|
return this.buffer[this.index++] - 128 & 0xff;
|
|
}
|
|
|
|
public final void writeByte(int value) {
|
|
this.buffer[this.index++] = (byte) value;
|
|
}
|
|
|
|
final void putBytes(byte[] bytes, int length) {
|
|
int i = 0;
|
|
while (length > i) {
|
|
this.buffer[this.index++] = bytes[i];
|
|
i++;
|
|
}
|
|
}
|
|
|
|
final int readUnsigned128Byte() {
|
|
return 128 - this.buffer[this.index++] & 255;
|
|
}
|
|
|
|
// TODO
|
|
final int getTriByte2() {
|
|
try {
|
|
this.index += 3;
|
|
return ((this.buffer[this.index + -2] & 255) << 8) + ((this.buffer[-1 + this.index] & 255) << 16) + (this.buffer[-3 + this.index] & 255);
|
|
} catch (RuntimeException var3) {
|
|
throw ClientErrorException.clientError(var3, "wa.BA(" + (byte) -118 + ')');
|
|
}
|
|
}
|
|
|
|
final long readLong() {
|
|
long msb = (long) this.readInt() & 0xFFFFFFFFL;
|
|
long lsb = (long) this.readInt() & 0xFFFFFFFFL;
|
|
return lsb + (msb << 32);
|
|
}
|
|
|
|
final void writeIntLE(int value) {
|
|
this.buffer[this.index++] = (byte) value;
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
this.buffer[this.index++] = (byte) (value >> 16);
|
|
this.buffer[this.index++] = (byte) (value >> 24);
|
|
}
|
|
|
|
final int readUnsignedShort128() {
|
|
this.index += 2;
|
|
return (this.buffer[this.index - 1] - 128 & 0xff)
|
|
+ ('\uff00' & this.buffer[this.index - 2] << 8);
|
|
}
|
|
|
|
final void writeIntV2(int value) {
|
|
this.buffer[this.index++] = (byte) (value >> 16);
|
|
this.buffer[this.index++] = (byte) (value >> 24);
|
|
this.buffer[this.index++] = (byte) value;
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
}
|
|
|
|
final byte readSignedByte() {
|
|
return this.buffer[this.index++];
|
|
}
|
|
|
|
// TODO
|
|
final RSString getGJString2(int var1) {
|
|
try {
|
|
byte var2 = this.buffer[this.index++];
|
|
if (var1 < 50) {
|
|
this.buffer = null;
|
|
}
|
|
|
|
if (0 == var2) {
|
|
int var3 = this.index;
|
|
|
|
while (Objects.requireNonNull(this.buffer)[this.index++] != 0) {
|
|
}
|
|
|
|
return Class3_Sub13_Sub3.bufferToString(this.buffer, this.index - (var3 - -1), var3);
|
|
} else {
|
|
throw new IllegalStateException("Bad version number in gjstr2");
|
|
}
|
|
} catch (RuntimeException var4) {
|
|
throw ClientErrorException.clientError(var4, "wa.DA(" + var1 + ')');
|
|
}
|
|
}
|
|
|
|
final void writeFloatLE(float value) {
|
|
int bits = Float.floatToRawIntBits(value);
|
|
|
|
this.buffer[this.index++] = (byte) bits;
|
|
this.buffer[this.index++] = (byte) (bits >> 8);
|
|
this.buffer[this.index++] = (byte) (bits >> 16);
|
|
this.buffer[this.index++] = (byte) (bits >> 24);
|
|
}
|
|
|
|
final byte readSignedNegativeByte() {
|
|
return (byte) -this.buffer[this.index++];
|
|
}
|
|
|
|
final void readBytes(byte[] out, int length) {
|
|
for (int i = 0; length > i; ++i) {
|
|
out[i] = this.buffer[this.index++];
|
|
}
|
|
}
|
|
|
|
final void writeShort128LE(int value) {
|
|
this.buffer[this.index++] = (byte) (value + 128);
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
}
|
|
|
|
final int readUnsignedShortLE() {
|
|
this.index += 2;
|
|
return (255 & this.buffer[this.index - 2])
|
|
+ ('\uff00' & this.buffer[this.index - 1] << 8);
|
|
}
|
|
|
|
// TODO Some smart
|
|
final void method768(int var2) {
|
|
if (0 <= var2 && var2 < 128) {
|
|
this.writeByte(var2);
|
|
} else if (0 <= var2 && var2 < 32768) {
|
|
this.writeShort('\u8000' + var2);
|
|
} else {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
// TODO finish varbyte length?
|
|
final void method769(int value) {
|
|
this.buffer[-1 + -value + this.index] = (byte) value;
|
|
}
|
|
|
|
public final void finishVarshortPacket(int value) {
|
|
this.buffer[this.index + -value - 2] = (byte) (value >> 8);
|
|
this.buffer[this.index + -value - 1] = (byte) value;
|
|
}
|
|
|
|
// TODO XTEA crypt?
|
|
final void method770(int[] var1, int var4) {
|
|
int var5 = this.index;
|
|
this.index = 5;
|
|
int var6 = (-5 + var4) / 8;
|
|
|
|
for (int var7 = 0; var6 > var7; ++var7) {
|
|
int var10 = -957401312;
|
|
int var8 = this.readInt();
|
|
int var9 = this.readInt();
|
|
int var12 = 32;
|
|
|
|
for (int var11 = -1640531527; var12-- > 0; var8 -= (var9 >>> 5 ^ var9 << 4) + var9 ^ var1[var10 & 3] + var10) {
|
|
var9 -= var1[(6754 & var10) >>> 11] + var10 ^ var8 + (var8 >>> 5 ^ var8 << 4);
|
|
var10 -= var11;
|
|
}
|
|
|
|
this.index -= 8;
|
|
this.writeInt(var8);
|
|
this.writeInt(var9);
|
|
}
|
|
|
|
this.index = var5;
|
|
}
|
|
|
|
// TODO
|
|
final void method771(int var2) {
|
|
if ((-128 & var2) != 0) {
|
|
if ((-16384 & var2) != 0) {
|
|
if ((var2 & -2097152) != 0) {
|
|
if (0 != (-268435456 & var2)) {
|
|
this.writeByte(var2 >>> 28 | 128);
|
|
}
|
|
|
|
this.writeByte(128 | var2 >>> 21);
|
|
}
|
|
|
|
this.writeByte(128 | var2 >>> 14);
|
|
}
|
|
|
|
this.writeByte(var2 >>> 7 | 128);
|
|
}
|
|
|
|
this.writeByte(var2 & 127);
|
|
}
|
|
|
|
// TODO
|
|
final long method772(int var1) {
|
|
--var1;
|
|
if (0 <= var1 && var1 <= 7) {
|
|
long var4 = 0L;
|
|
|
|
for (int var3 = var1 * 8; var3 >= 0; var3 -= 8) {
|
|
var4 |= ((long) this.buffer[this.index++] & 255L) << var3;
|
|
}
|
|
|
|
return var4;
|
|
} else {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
}
|
|
|
|
// TODO
|
|
final int method773() {
|
|
int var3 = this.getSmart();
|
|
|
|
int var2;
|
|
for (var2 = 0; 32767 == var3; var2 += 32767) {
|
|
var3 = this.getSmart();
|
|
}
|
|
|
|
var2 += var3;
|
|
return var2;
|
|
}
|
|
|
|
final void readBytesReverse(int length, byte[] out) {
|
|
for (int i = -(-length - -1); i >= 0; --i) {
|
|
out[i] = this.buffer[this.index++];
|
|
}
|
|
}
|
|
|
|
final void writeIntV1(int value) {
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
this.buffer[this.index++] = (byte) value;
|
|
this.buffer[this.index++] = (byte) (value >> 24);
|
|
this.buffer[this.index++] = (byte) (value >> 16);
|
|
}
|
|
|
|
public final RSString readString() {
|
|
int startIndex = this.index;
|
|
|
|
while (this.buffer[this.index++] != 0) ;
|
|
|
|
return Class3_Sub13_Sub3.bufferToString(this.buffer, (this.index - 1) - startIndex, startIndex);
|
|
}
|
|
|
|
final int getSmart() {
|
|
int var2 = this.buffer[this.index] & 255;
|
|
return 128 <= var2 ? -32768 + this.readUnsignedShort() : this.readUnsignedByte();
|
|
}
|
|
|
|
final void writeMedium(int value) {
|
|
this.buffer[this.index++] = (byte) (value >> 16);
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
this.buffer[this.index++] = (byte) value;
|
|
}
|
|
|
|
final int readIntV1() {
|
|
this.index += 4;
|
|
return ((this.buffer[this.index - 2] & 255) << 24) +
|
|
((this.buffer[this.index - 1] & 255) << 16) +
|
|
('\uff00' & this.buffer[this.index - 4] << 8) +
|
|
(this.buffer[this.index + -3] & 255);
|
|
}
|
|
|
|
final int readUnsignedShortLE128() {
|
|
this.index += 2;
|
|
return (this.buffer[this.index - 1] << 8 & '\uff00') +
|
|
(255 & this.buffer[this.index - 2] - 128);
|
|
}
|
|
|
|
final int readIntLE() {
|
|
this.index += 4;
|
|
return (255 & this.buffer[-4 + this.index]) +
|
|
(16711680 & this.buffer[this.index - 2] << 16) +
|
|
((255 & this.buffer[this.index + -1]) << 24) +
|
|
((this.buffer[-3 + this.index] & 255) << 8);
|
|
}
|
|
|
|
final void putShortA(int var1) {
|
|
this.buffer[this.index++] = (byte) (var1 >> 8);
|
|
this.buffer[this.index++] = (byte) (128 + var1);
|
|
}
|
|
|
|
// TODO What is the difference between this and WriteIntLE?
|
|
final void writeIntLE2(int value) {
|
|
this.buffer[this.index++] = (byte) value;
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
this.buffer[this.index++] = (byte) (value >> 16);
|
|
this.buffer[this.index++] = (byte) (value >> 24);
|
|
}
|
|
|
|
final int readUnsignedNegativeByte() {
|
|
return -this.buffer[this.index++] & 0xff;
|
|
}
|
|
|
|
final int readSignedShort() {
|
|
this.index += 2;
|
|
int value = (this.buffer[-1 + this.index] & 255) + ((255 & this.buffer[this.index + -2]) << 8);
|
|
if (value > 32767) {
|
|
value -= 65536;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
final int readSignedShortLE128() {
|
|
this.index += 2;
|
|
int var2 = ((this.buffer[this.index - 1] & 255) << 8) + (this.buffer[-2 + this.index] - 128 & 255);
|
|
|
|
if (32767 < var2) {
|
|
var2 -= 65536;
|
|
}
|
|
|
|
return var2;
|
|
}
|
|
|
|
final byte readSignedByte128() {
|
|
return (byte) (this.buffer[this.index++] - 128);
|
|
}
|
|
|
|
final void writeByte128(int value) {
|
|
this.buffer[this.index++] = (byte) (128 + value);
|
|
}
|
|
|
|
final int readSignedShortLE() {
|
|
this.index += 2;
|
|
|
|
int value = (this.buffer[-2 + this.index] & 255) + ('\uff00' & this.buffer[this.index + -1] << 8);
|
|
if (value > 32767) {
|
|
value -= 65536;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
final void writeCRC(int startOffset) {
|
|
int crc = CRC.INSTANCE.crc32(this.buffer, startOffset, this.index);
|
|
this.writeInt(crc);
|
|
}
|
|
|
|
public final int readMedium() {
|
|
this.index += 3;
|
|
return (16711680 & this.buffer[this.index + -3] << 16) +
|
|
(('\uff00' & this.buffer[-2 + this.index] << 8) +
|
|
(this.buffer[this.index + -1] & 255));
|
|
}
|
|
|
|
final void writeShortLE(int value) {
|
|
this.buffer[this.index++] = (byte) value;
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
}
|
|
|
|
// TODO
|
|
final int getSmart(int var1) {
|
|
int var2 = this.buffer[this.index] & 255;
|
|
return var2 < 128 ? -64 + this.readUnsignedByte() : this.readUnsignedShort() - '\uc000';
|
|
}
|
|
|
|
final int readIntV2() {
|
|
this.index += 4;
|
|
return ((this.buffer[this.index + -3] & 255) << 24) +
|
|
(16711680 & this.buffer[this.index + -4] << 16) +
|
|
((this.buffer[this.index + -1] & 255) << 8) +
|
|
(255 & this.buffer[this.index + -2]);
|
|
}
|
|
|
|
final void rsaEncrypt(BigInteger var1, BigInteger var2) {
|
|
int var4 = this.index;
|
|
this.index = 0;
|
|
byte[] var5 = new byte[var4];
|
|
this.readBytes(var5, var4);
|
|
BigInteger var6 = new BigInteger(var5);
|
|
BigInteger var7;
|
|
if (GameConfig.RSA)
|
|
var7 = var6.modPow(var1, var2);
|
|
else
|
|
var7 = var6;
|
|
byte[] var8 = var7.toByteArray();
|
|
this.index = 0;
|
|
this.writeByte(var8.length);
|
|
this.putBytes(var8, var8.length);
|
|
}
|
|
|
|
final void writeFloat(float value) {
|
|
int bits = Float.floatToRawIntBits(value);
|
|
|
|
this.buffer[this.index++] = (byte) (bits >> 24);
|
|
this.buffer[this.index++] = (byte) (bits >> 16);
|
|
this.buffer[this.index++] = (byte) (bits >> 8);
|
|
this.buffer[this.index++] = (byte) bits;
|
|
}
|
|
|
|
public final int readUnsignedByte() {
|
|
return this.buffer[this.index++] & 255;
|
|
}
|
|
|
|
public final void writeShort(int value) {
|
|
this.buffer[this.index++] = (byte) (value >> 8);
|
|
this.buffer[this.index++] = (byte) value;
|
|
}
|
|
|
|
}
|