package kan;
/*
* BeDecoder.java
*
* Created on May 30, 2003, 2:44 PM
* Copyright (C) 2003, 2004, 2005, 2006 Aelitis, All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* AELITIS, SAS au capital de 46,603.30 euros
* 8 Allee Lenotre, La Grille Royale, 78600 Le Mesnil le Roi, France.
*/
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* A set of utility methods to decode a bencoded array of byte into a Map.
* integer are represented as Long, String as byte[], dictionnaries as Map, and
* list as List.
*
* @author TdC_VgA
*
*/
@SuppressWarnings(value={"rawtypes", "unchecked", "unused"})
public class BDecoder {
public static Charset BYTE_CHARSET = Charset.forName("UTF-8");;
public static Charset DEFAULT_CHARSET = Charset.forName("UTF-8");;
private boolean recovery_mode;
public static Map decode(byte[] data) throws IOException {
return (new BDecoder().decodeByteArray(data));
}
public static Map decode(BufferedInputStream is) throws IOException {
return (new BDecoder().decodeStream(is));
}
public BDecoder() { }
public Map decodeByteArray(byte[] data) throws IOException {
return (decode(new ByteArrayInputStream(data)));
}
public Map decodeStream(BufferedInputStream data) throws IOException {
Object res = decodeInputStream(data, 0);
if (res == null) {
throw (new IOException("BDecoder: zero length file"));
} else if (!(res instanceof Map)) {
throw (new IOException("BDecoder: top level isn't a Map"));
}
return ((Map) res);
}
private Map decode(ByteArrayInputStream data) throws IOException {
Object res = decodeInputStream(data, 0);
if (res == null) {
throw (new IOException("BDecoder: zero length file"));
} else if (!(res instanceof Map)) {
throw (new IOException("BDecoder: top level isn't a Map"));
}
return ((Map) res);
}
private Object decodeInputStream(InputStream bais, int nesting)
throws IOException {
if (nesting == 0 && !bais.markSupported()) {
throw new IOException("InputStream must support the mark() method");
}
// set a mark
bais.mark(Integer.MAX_VALUE);
// read a byte
int tempByte = bais.read();
// decide what to do
switch (tempByte) {
case 'd':
// create a new dictionary object
Map tempMap = new HashMap();
try {
// get the key
byte[] tempByteArray = null;
while ((tempByteArray =
(byte[]) decodeInputStream(bais,nesting + 1)) != null) {
// decode some more
Object value = decodeInputStream(bais, nesting + 1);
// add the value to the map
CharBuffer cb =
BYTE_CHARSET.decode(ByteBuffer.wrap(tempByteArray));
String key = new String(cb.array(), 0, cb.limit());
tempMap.put(key, value);
}
bais.mark(Integer.MAX_VALUE);
tempByte = bais.read();
bais.reset();
if (nesting > 0 && tempByte == -1) {
throw (new IOException(
"BDecoder: invalid input data, 'e' missing from end of dictionary"));
}
} catch (Throwable e) {
if (!recovery_mode) {
if (e instanceof IOException) {
throw ((IOException) e);
}
throw (new IOException(e.toString()));
}
}
// return the map
return tempMap;
case 'l':
// create the list
List tempList = new ArrayList();
try {
// create the key
Object tempElement = null;
while ((tempElement = decodeInputStream(bais, nesting + 1)) != null) {
// add the element
tempList.add(tempElement);
}
bais.mark(Integer.MAX_VALUE);
tempByte = bais.read();
bais.reset();
if (nesting > 0 && tempByte == -1) {
throw (new IOException(
"BDecoder: invalid input data, 'e' missing from end of list"));
}
} catch (Throwable e) {
if (!recovery_mode) {
if (e instanceof IOException) {
throw ((IOException) e);
}
throw (new IOException(e.toString()));
}
}
// return the list
return tempList;
case 'e':
case -1:
return null;
case 'i':
return new Long(getNumberFromStream(bais, 'e'));
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
// move back one
bais.reset();
// get the string
return getByteArrayFromStream(bais);
default: {
int rem_len = bais.available();
if (rem_len > 256) {
rem_len = 256;
}
byte[] rem_data = new byte[rem_len];
bais.read(rem_data);
throw (new IOException("BDecoder: unknown command '" + tempByte
+ ", remainder = " + new String(rem_data, DEFAULT_CHARSET)));
}
}
}
private long getNumberFromStream(
InputStream bais, char parseChar)throws IOException {
StringBuffer sb = new StringBuffer(3);
int tempByte = bais.read();
while ((tempByte != parseChar) && (tempByte >= 0)) {
sb.append((char) tempByte);
tempByte = bais.read();
}
// are we at the end of the stream?
if (tempByte < 0) {
return -1;
}
return Long.parseLong(sb.toString());
}
// This one causes lots of "Query Information" calls to the filesystem
private long getNumberFromStreamOld(
InputStream bais, char parseChar) throws IOException {
int length = 0;
// place a mark
bais.mark(Integer.MAX_VALUE);
int tempByte = bais.read();
while ((tempByte != parseChar) && (tempByte >= 0)) {
tempByte = bais.read();
length++;
}
// are we at the end of the stream?
if (tempByte < 0) {
return -1;
}
// reset the mark
bais.reset();
// get the length
byte[] tempArray = new byte[length];
int count = 0;
int len = 0;
// get the string
while (count != length
&& (len = bais.read(tempArray, count, length - count)) > 0) {
count += len;
}
// jump ahead in the stream to compensate for the :
bais.skip(1);
// return the value
CharBuffer cb =
DEFAULT_CHARSET.decode(ByteBuffer.wrap(tempArray));
String str_value = new String(cb.array(), 0, cb.limit());
return Long.parseLong(str_value);
}
private byte[] getByteArrayFromStream(
InputStream bais) throws IOException {
int length = (int) getNumberFromStream(bais, ':');
if (length < 0) {
return null;
}
// note that torrent hashes can be big (consider a 55GB file with 2MB
// pieces
// this generates a pieces hash of 1/2 meg
if (length > 8 * 1024 * 1024) {
throw new IOException("Byte array length too large (" + length + ")");
}
byte[] tempArray = new byte[length];
int count = 0;
int len = 0;
// get the string
while (count != length
&& (len = bais.read(tempArray, count, length - count)) > 0) {
count += len;
}
if (count != tempArray.length) {
throw (new IOException(
"BDecoder::getByteArrayFromStream: truncated"));
}
return tempArray;
}
public void setRecoveryMode(boolean r) {
recovery_mode = r;
}
private void print(PrintWriter writer, Object obj) {
print(writer, obj, "", false);
}
private void print(
PrintWriter writer, Object obj, String indent, boolean skip_indent) {
String use_indent = skip_indent ? "" : indent;
if (obj instanceof Long) {
writer.println(use_indent + obj);
} else if (obj instanceof byte[]) {
byte[] b = (byte[]) obj;
if (b.length == 20) {
writer.println(use_indent + " { " + b + " }");
} else if (b.length < 64) {
writer.println(new String(b, DEFAULT_CHARSET));
} else {
writer.println("[byte array length " + b.length);
}
} else if (obj instanceof String) {
writer.println(use_indent + obj);
} else if (obj instanceof List) {
List l = (List) obj;
writer.println(use_indent + "[");
for (int i = 0; i < l.size(); i++) {
writer.print(indent + " (" + i + ") ");
print(writer, l.get(i), indent + " ", true);
}
writer.println(indent + "]");
} else {
Map m = (Map) obj;
Iterator it = m.keySet().iterator();
while (it.hasNext()) {
String key = (String) it.next();
if (key.length() > 256) {
writer.print(indent + key.substring(0, 256) + "... = ");
} else {
writer.print(indent + key + " = ");
}
print(writer, m.get(key), indent + " ", true);
}
}
}
private static void print(File f, File output) {
try {
BDecoder decoder = new BDecoder();
decoder.setRecoveryMode(false);
PrintWriter pw = new PrintWriter(new FileWriter(output));
decoder.print(pw,
decoder.decodeStream(
new BufferedInputStream(new FileInputStream(f))));
pw.flush();
} catch (Throwable e) {
}
}
public static void main(String[] args) {
//print(new File(
//"C:\\Temp\\8565658FA6C187A602A5360A69F11933624DD9B5.dat.bak"),
//new File("C:\\Temp\\bdecoder.log"));
//print(new File("D:/Users/Desktop/WorkSpace/torrent/1.torrent"), new File("D:/Users/kanlianhui689/Desktop/WorkSpace/torrent/1.text"));
print(new File("D:/Users/Desktop/WorkSpace/torrent/1.torrent"), new File("D:/Users/kanlianhui689/Desktop/WorkSpace/torrent/1.text"));
}
}