CrackMe.apk
Download file
package org.apache.commons.io.input;
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import org.apache.commons.io.Charsets;
import org.apache.commons.io.IOUtils;
public class ReversedLinesFileReader implements Closeable {
/* access modifiers changed from: private */
public final int avoidNewlineSplitBufferSize;
/* access modifiers changed from: private */
public final int blockSize;
/* access modifiers changed from: private */
public final int byteDecrement;
private FilePart currentFilePart;
/* access modifiers changed from: private */
public final Charset encoding;
/* access modifiers changed from: private */
public final byte[][] newLineSequences;
/* access modifiers changed from: private */
public final RandomAccessFile randomAccessFile;
private final long totalBlockCount;
private final long totalByteLength;
private boolean trailingNewlineOfFileSkipped;
@Deprecated
public ReversedLinesFileReader(File file) throws IOException {
this(file, 4096, Charset.defaultCharset());
}
public ReversedLinesFileReader(File file, Charset charset) throws IOException {
this(file, 4096, charset);
}
public ReversedLinesFileReader(File file, int i, Charset charset) throws IOException {
int i2;
this.trailingNewlineOfFileSkipped = false;
this.blockSize = i;
this.encoding = charset;
Charset charset2 = Charsets.toCharset(charset);
if (charset2.newEncoder().maxBytesPerChar() == 1.0f) {
this.byteDecrement = 1;
} else if (charset2 == StandardCharsets.UTF_8) {
this.byteDecrement = 1;
} else if (charset2 == Charset.forName("Shift_JIS") || charset2 == Charset.forName("windows-31j") || charset2 == Charset.forName("x-windows-949") || charset2 == Charset.forName("gbk") || charset2 == Charset.forName("x-windows-950")) {
this.byteDecrement = 1;
} else if (charset2 == StandardCharsets.UTF_16BE || charset2 == StandardCharsets.UTF_16LE) {
this.byteDecrement = 2;
} else if (charset2 == StandardCharsets.UTF_16) {
throw new UnsupportedEncodingException("For UTF-16, you need to specify the byte order (use UTF-16BE or UTF-16LE)");
} else {
throw new UnsupportedEncodingException("Encoding " + charset + " is not supported yet (feel free to submit a patch)");
}
byte[][] bArr = {IOUtils.LINE_SEPARATOR_WINDOWS.getBytes(charset), "\n".getBytes(charset), "\r".getBytes(charset)};
this.newLineSequences = bArr;
this.avoidNewlineSplitBufferSize = bArr[0].length;
RandomAccessFile randomAccessFile2 = new RandomAccessFile(file, "r");
this.randomAccessFile = randomAccessFile2;
long length = randomAccessFile2.length();
this.totalByteLength = length;
long j = (long) i;
int i3 = (int) (length % j);
if (i3 > 0) {
this.totalBlockCount = (length / j) + 1;
} else {
this.totalBlockCount = length / j;
if (length > 0) {
i2 = i;
this.currentFilePart = new FilePart(this.totalBlockCount, i2, (byte[]) null);
}
}
i2 = i3;
this.currentFilePart = new FilePart(this.totalBlockCount, i2, (byte[]) null);
}
public ReversedLinesFileReader(File file, int i, String str) throws IOException {
this(file, i, Charsets.toCharset(str));
}
public String readLine() throws IOException {
String access$100 = this.currentFilePart.readLine();
while (access$100 == null) {
FilePart access$200 = this.currentFilePart.rollOver();
this.currentFilePart = access$200;
if (access$200 == null) {
break;
}
access$100 = access$200.readLine();
}
if (!"".equals(access$100) || this.trailingNewlineOfFileSkipped) {
return access$100;
}
this.trailingNewlineOfFileSkipped = true;
return readLine();
}
public void close() throws IOException {
this.randomAccessFile.close();
}
private class FilePart {
private int currentLastBytePos;
private final byte[] data;
private byte[] leftOver;
private final long no;
private FilePart(long j, int i, byte[] bArr) throws IOException {
this.no = j;
byte[] bArr2 = new byte[((bArr != null ? bArr.length : 0) + i)];
this.data = bArr2;
long access$300 = (j - 1) * ((long) ReversedLinesFileReader.this.blockSize);
if (j > 0) {
ReversedLinesFileReader.this.randomAccessFile.seek(access$300);
if (ReversedLinesFileReader.this.randomAccessFile.read(bArr2, 0, i) != i) {
throw new IllegalStateException("Count of requested bytes and actually read bytes don't match");
}
}
if (bArr != null) {
System.arraycopy(bArr, 0, bArr2, i, bArr.length);
}
this.currentLastBytePos = bArr2.length - 1;
this.leftOver = null;
}
/* access modifiers changed from: private */
public FilePart rollOver() throws IOException {
if (this.currentLastBytePos <= -1) {
long j = this.no;
if (j > 1) {
ReversedLinesFileReader reversedLinesFileReader = ReversedLinesFileReader.this;
return new FilePart(j - 1, reversedLinesFileReader.blockSize, this.leftOver);
} else if (this.leftOver == null) {
return null;
} else {
throw new IllegalStateException("Unexpected leftover of the last block: leftOverOfThisFilePart=" + new String(this.leftOver, ReversedLinesFileReader.this.encoding));
}
} else {
throw new IllegalStateException("Current currentLastCharPos unexpectedly positive... last readLine() should have returned something! currentLastCharPos=" + this.currentLastBytePos);
}
}
/* access modifiers changed from: private */
public String readLine() throws IOException {
String str;
byte[] bArr;
boolean z = this.no == 1;
int i = this.currentLastBytePos;
while (true) {
if (i > -1) {
if (!z && i < ReversedLinesFileReader.this.avoidNewlineSplitBufferSize) {
createLeftOver();
break;
}
int newLineMatchByteCount = getNewLineMatchByteCount(this.data, i);
if (newLineMatchByteCount <= 0) {
i -= ReversedLinesFileReader.this.byteDecrement;
if (i < 0) {
createLeftOver();
break;
}
} else {
int i2 = i + 1;
int i3 = (this.currentLastBytePos - i2) + 1;
if (i3 >= 0) {
byte[] bArr2 = new byte[i3];
System.arraycopy(this.data, i2, bArr2, 0, i3);
str = new String(bArr2, ReversedLinesFileReader.this.encoding);
this.currentLastBytePos = i - newLineMatchByteCount;
} else {
throw new IllegalStateException("Unexpected negative line length=" + i3);
}
}
} else {
break;
}
}
str = null;
if (!z || (bArr = this.leftOver) == null) {
return str;
}
String str2 = new String(bArr, ReversedLinesFileReader.this.encoding);
this.leftOver = null;
return str2;
}
private void createLeftOver() {
int i = this.currentLastBytePos + 1;
if (i > 0) {
byte[] bArr = new byte[i];
this.leftOver = bArr;
System.arraycopy(this.data, 0, bArr, 0, i);
} else {
this.leftOver = null;
}
this.currentLastBytePos = -1;
}
private int getNewLineMatchByteCount(byte[] bArr, int i) {
for (byte[] bArr2 : ReversedLinesFileReader.this.newLineSequences) {
boolean z = true;
for (int length = bArr2.length - 1; length >= 0; length--) {
int length2 = (i + length) - (bArr2.length - 1);
z &= length2 >= 0 && bArr[length2] == bArr2[length];
}
if (z) {
return bArr2.length;
}
}
return 0;
}
}
}
Download file