This is an I2P port of snark [http://klomp.org/snark], a GPL'ed bittorrent client

The build in tracker has been removed for simplicity.

Example usage:
  java -jar lib/i2psnark.jar myFile.torrent

or, a more verbose setting:
  java -jar lib/i2psnark.jar --eepproxy 127.0.0.1 4444 \
       --i2cp 127.0.0.1 7654 "inbound.length=2 outbound.length=2" \
       --debug 6 myFile.torrent

apps/i2psnark/java/src/org/klomp/snark/bencode/BDecoder.java

@@ -0,0 +1,355 @@
+/* BDecoder - Converts an InputStream to BEValues.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   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, 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.
+*/
+
+package org.klomp.snark.bencode;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.EOFException;
+import java.io.UnsupportedEncodingException;
+
+import java.math.BigInteger;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * Decodes a bencoded stream to <code>BEValue</code>s.
+ *
+ * A bencoded byte stream can represent byte arrays, numbers, lists and
+ * maps (dictionaries).
+ *
+ * It currently contains a hack to indicate a name of a dictionary of
+ * which a SHA-1 digest hash should be calculated (the hash over the
+ * original bencoded bytes).
+ *
+ * @author Mark Wielaard (mark@klomp.org).
+ */
+public class BDecoder
+{
+  // The InputStream to BDecode.
+  private final InputStream in;
+
+  // The last indicator read.
+  // Zero if unknown.
+  // '0'..'9' indicates a byte[].
+  // 'i' indicates an Number.
+  // 'l' indicates a List.
+  // 'd' indicates a Map.
+  // 'e' indicates end of Number, List or Map (only used internally).
+  // -1 indicates end of stream.
+  // Call getNextIndicator to get the current value (will never return zero).
+  private int indicator = 0;
+
+  // Used for ugly hack to get SHA hash over the metainfo info map
+  private String special_map = "info";
+  private boolean in_special_map = false;
+  private final MessageDigest sha_digest;
+
+  // Ugly hack. Return the SHA has over bytes that make up the special map.
+  public byte[] get_special_map_digest()
+  {
+    byte[] result = sha_digest.digest();
+    return result;
+  }
+
+  // Ugly hack. Name defaults to "info".
+  public void set_special_map_name(String name)
+  {
+    special_map = name;
+  }
+
+  /**
+   * Initalizes a new BDecoder. Nothing is read from the given
+   * <code>InputStream</code> yet.
+   */
+  public BDecoder(InputStream in)
+  {
+    this.in = in;
+    // XXX - Used for ugly hack.
+    try
+      {
+        sha_digest = MessageDigest.getInstance("SHA");
+      }
+    catch(NoSuchAlgorithmException nsa)
+      {
+        throw new InternalError(nsa.toString());
+      }
+  }
+
+  /**
+   * Creates a new BDecoder and immediatly decodes the first value it
+   * sees.
+   *
+   * @return The first BEValue on the stream or null when the stream
+   * has ended.
+   *
+   * @exception InvalidBEncoding when the stream doesn't start with a
+   * bencoded value or the stream isn't a bencoded stream at all.
+   * @exception IOException when somthing bad happens with the stream
+   * to read from.
+   */
+  public static BEValue bdecode(InputStream in) throws IOException
+  {
+    return new BDecoder(in).bdecode();
+  }
+
+  /**
+   * Returns what the next bencoded object will be on the stream or -1
+   * when the end of stream has been reached. Can return something
+   * unexpected (not '0' .. '9', 'i', 'l' or 'd') when the stream
+   * isn't bencoded.
+   *
+   * This might or might not read one extra byte from the stream.
+   */
+  public int getNextIndicator() throws IOException
+  {
+    if (indicator == 0)
+      {
+        indicator = in.read();
+        // XXX - Used for ugly hack
+        if (in_special_map) sha_digest.update((byte)indicator);
+      }
+    return indicator;
+  }
+
+  /**
+   * Gets the next indicator and returns either null when the stream
+   * has ended or bdecodes the rest of the stream and returns the
+   * appropriate BEValue encoded object.
+   */
+  public BEValue bdecode() throws IOException
+  {
+    indicator = getNextIndicator();
+    if (indicator == -1)
+      return null;
+
+    if (indicator >= '0' && indicator <= '9')
+      return bdecodeBytes();
+    else if (indicator == 'i')
+      return bdecodeNumber();
+    else if (indicator == 'l')
+      return bdecodeList();
+    else if (indicator == 'd')
+      return bdecodeMap();
+    else
+      throw new InvalidBEncodingException
+        ("Unknown indicator '" + indicator + "'");
+  }
+
+  /**
+   * Returns the next bencoded value on the stream and makes sure it
+   * is a byte array. If it is not a bencoded byte array it will throw
+   * InvalidBEncodingException.
+   */
+  public BEValue bdecodeBytes() throws IOException
+  {
+    int c = getNextIndicator();
+    int num = c - '0';
+    if (num < 0 || num > 9)
+      throw new InvalidBEncodingException("Number expected, not '"
+                                          + (char)c + "'");
+    indicator = 0;
+
+    c = read();
+    int i = c - '0';
+    while (i >= 0 && i <= 9)
+      {
+        // XXX - This can overflow!
+        num = num*10 + i;
+        c = read();
+        i = c - '0';
+      }
+
+    if (c != ':')
+      throw new InvalidBEncodingException("Colon expected, not '"
+                                          + (char)c + "'");
+
+    return new BEValue(read(num));
+  }
+
+  /**
+   * Returns the next bencoded value on the stream and makes sure it
+   * is a number. If it is not a number it will throw
+   * InvalidBEncodingException.
+   */
+  public BEValue bdecodeNumber() throws IOException
+  {
+    int c = getNextIndicator();
+    if (c != 'i')
+      throw new InvalidBEncodingException("Expected 'i', not '"
+                                          + (char)c + "'");
+    indicator = 0;
+
+    c = read();
+    if (c == '0')
+      {
+        c = read();
+        if (c == 'e')
+          return new BEValue(BigInteger.ZERO);
+        else
+          throw new InvalidBEncodingException("'e' expected after zero,"
+                                              + " not '" + (char)c + "'");
+      }
+
+    // XXX - We don't support more the 255 char big integers
+    char[] chars = new char[256];
+    int off = 0;
+
+    if (c == '-')
+      {
+        c = read();
+        if (c == '0')
+          throw new InvalidBEncodingException("Negative zero not allowed");
+        chars[off] = (char)c;
+        off++;
+      }
+
+    if (c < '1' || c > '9')
+      throw new InvalidBEncodingException("Invalid Integer start '"
+                                          + (char)c + "'");
+    chars[off] = (char)c;
+    off++;
+
+    c = read();
+    int i = c - '0';
+    while(i >= 0 && i <= 9)
+      {
+        chars[off] = (char)c;
+        off++;
+        c = read();
+        i = c - '0';
+      }
+
+    if (c != 'e')
+      throw new InvalidBEncodingException("Integer should end with 'e'");
+
+    String s = new String(chars, 0, off);
+    return new BEValue(new BigInteger(s));
+  }
+
+  /**
+   * Returns the next bencoded value on the stream and makes sure it
+   * is a list. If it is not a list it will throw
+   * InvalidBEncodingException.
+   */
+  public BEValue bdecodeList() throws IOException
+  {
+    int c = getNextIndicator();
+    if (c != 'l')
+      throw new InvalidBEncodingException("Expected 'l', not '"
+                                          + (char)c + "'");
+    indicator = 0;
+
+    List result = new ArrayList();
+    c = getNextIndicator();
+    while (c != 'e')
+      {
+        result.add(bdecode());
+        c = getNextIndicator();
+      }
+    indicator = 0;
+
+    return new BEValue(result);
+  }
+
+  /**
+   * Returns the next bencoded value on the stream and makes sure it
+   * is a map (dictonary). If it is not a map it will throw
+   * InvalidBEncodingException.
+   */
+  public BEValue bdecodeMap() throws IOException
+  {
+    int c = getNextIndicator();
+    if (c != 'd')
+      throw new InvalidBEncodingException("Expected 'd', not '"
+                                          + (char)c + "'");
+    indicator = 0;
+
+    Map result = new HashMap();
+    c = getNextIndicator();
+    while (c != 'e')
+      {
+        // Dictonary keys are always strings.
+        String key = bdecode().getString();
+
+        // XXX ugly hack
+        boolean special = special_map.equals(key);
+        if (special)
+          in_special_map = true;
+
+        BEValue value = bdecode();
+        result.put(key, value);
+
+        // XXX ugly hack continued
+        if (special)
+          in_special_map = false;
+        
+        c = getNextIndicator();
+      }
+    indicator = 0;
+
+    return new BEValue(result);
+  }
+
+  /**
+   * Returns the next byte read from the InputStream (as int).
+   * Throws EOFException if InputStream.read() returned -1.
+   */
+  private int read() throws IOException
+  {
+    int c = in.read();
+    if (c == -1)
+      throw new EOFException();
+    if (in_special_map) sha_digest.update((byte)c);
+    return c;
+  }
+
+  /**
+   * Returns a byte[] containing length valid bytes starting at offset
+   * zero.  Throws EOFException if InputStream.read() returned -1
+   * before all requested bytes could be read.  Note that the byte[]
+   * returned might be bigger then requested but will only contain
+   * length valid bytes.  The returned byte[] will be reused when this
+   * method is called again.
+   */
+  private byte[] read(int length) throws IOException
+  {
+    byte[] result = new byte[length];
+    
+    int read = 0;
+    while (read < length)
+      {
+        int i = in.read(result, read, length - read);
+        if (i == -1)
+          throw new EOFException();
+        read += i;
+      }
+
+    if (in_special_map) sha_digest.update(result, 0, length);
+    return result;
+  }
+
+}

apps/i2psnark/java/src/org/klomp/snark/bencode/BEValue.java

@@ -0,0 +1,190 @@
+/* BEValue - Holds different types that a bencoded byte array can represent.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   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, 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.
+*/
+
+package org.klomp.snark.bencode;
+
+import java.io.UnsupportedEncodingException;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Holds different types that a bencoded byte array can represent.
+ * You need to call the correct get method to get the correct java
+ * type object. If the BEValue wasn't actually of the requested type
+ * you will get a InvalidBEncodingException.
+ *
+ * @author Mark Wielaard (mark@klomp.org)
+ */
+public class BEValue
+{
+  // This is either a byte[], Number, List or Map.
+  private final Object value;
+
+  public BEValue(byte[] value)
+  {
+    this.value = value;
+  }
+
+  public BEValue(Number value)
+  {
+    this.value = value;
+  }
+
+  public BEValue(List value)
+  {
+    this.value = value;
+  }
+
+  public BEValue(Map value)
+  {
+    this.value = value;
+  }
+
+  /**
+   * Returns this BEValue as a String. This operation only succeeds
+   * when the BEValue is a byte[], otherwise it will throw a
+   * InvalidBEncodingException. The byte[] will be interpreted as
+   * UTF-8 encoded characters.
+   */
+  public String getString() throws InvalidBEncodingException
+  {
+    try
+      {
+        return new String(getBytes(), "UTF-8");
+      }
+    catch (ClassCastException cce)
+      {
+        throw new InvalidBEncodingException(cce.toString());
+      }
+    catch (UnsupportedEncodingException uee)
+      {
+        throw new InternalError(uee.toString());
+      }
+  }
+
+  /**
+   * Returns this BEValue as a byte[]. This operation only succeeds
+   * when the BEValue is actually a byte[], otherwise it will throw a
+   * InvalidBEncodingException.
+   */
+  public byte[] getBytes() throws InvalidBEncodingException
+  {
+    try
+      {
+        return (byte[])value;
+      }
+    catch (ClassCastException cce)
+      {
+        throw new InvalidBEncodingException(cce.toString());
+      }
+  }
+
+  /**
+   * Returns this BEValue as a Number. This operation only succeeds
+   * when the BEValue is actually a Number, otherwise it will throw a
+   * InvalidBEncodingException.
+   */
+  public Number getNumber() throws InvalidBEncodingException
+  {
+    try
+      {
+        return (Number)value;
+      }
+    catch (ClassCastException cce)
+      {
+        throw new InvalidBEncodingException(cce.toString());
+      }
+  }
+
+  /**
+   * Returns this BEValue as int. This operation only succeeds when
+   * the BEValue is actually a Number, otherwise it will throw a
+   * InvalidBEncodingException. The returned int is the result of
+   * <code>Number.intValue()</code>.
+   */
+  public int getInt() throws InvalidBEncodingException
+  {
+    return getNumber().intValue();
+  }
+
+  /**
+   * Returns this BEValue as long. This operation only succeeds when
+   * the BEValue is actually a Number, otherwise it will throw a
+   * InvalidBEncodingException. The returned long is the result of
+   * <code>Number.longValue()</code>.
+   */
+  public long getLong() throws InvalidBEncodingException
+  {
+    return getNumber().longValue();
+  }
+
+  /**
+   * Returns this BEValue as a List of BEValues. This operation only
+   * succeeds when the BEValue is actually a List, otherwise it will
+   * throw a InvalidBEncodingException.
+   */
+  public List getList() throws InvalidBEncodingException
+  {
+    try
+      {
+        return (List)value;
+      }
+    catch (ClassCastException cce)
+      {
+        throw new InvalidBEncodingException(cce.toString());
+      }
+  }
+
+  /**
+   * Returns this BEValue as a Map of BEValue keys and BEValue
+   * values. This operation only succeeds when the BEValue is actually
+   * a Map, otherwise it will throw a InvalidBEncodingException.
+   */
+  public Map getMap() throws InvalidBEncodingException
+  {
+    try
+      {
+        return (Map)value;
+      }
+    catch (ClassCastException cce)
+      {
+        throw new InvalidBEncodingException(cce.toString());
+      }
+  }
+
+  public String toString()
+  {
+    String valueString;
+    if (value instanceof byte[])
+      {
+        byte[] bs = (byte[])value;
+        // XXX - Stupid heuristic...
+        if (bs.length <= 12)
+          valueString = new String(bs);
+        else
+          valueString = "bytes:" + bs.length;
+      }
+    else
+      valueString = value.toString();
+
+    return "BEValue[" + valueString + "]";
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/bencode/BEncoder.java

@@ -0,0 +1,191 @@
+/* BDecoder - Converts an InputStream to BEValues.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   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, 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.
+*/
+
+package org.klomp.snark.bencode;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.UnsupportedEncodingException;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class BEncoder
+{
+
+  public static byte[] bencode(Object o) throws IllegalArgumentException
+  {
+    try
+      {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        bencode(o, baos);
+        return baos.toByteArray();
+      }
+    catch (IOException ioe)
+      {
+        throw new InternalError(ioe.toString());
+      }
+  }
+
+  public static void bencode(Object o, OutputStream out)
+    throws IOException, IllegalArgumentException
+  {
+    if (o instanceof String)
+      bencode((String)o, out);
+    else if (o instanceof byte[])
+      bencode((byte[])o, out);
+    else if (o instanceof Number)
+      bencode((Number)o, out);
+    else if (o instanceof List)
+      bencode((List)o, out);
+    else if (o instanceof Map)
+      bencode((Map)o, out);
+    else
+      throw new IllegalArgumentException("Cannot bencode: " + o.getClass());
+  }
+
+  public static byte[] bencode(String s)
+  {
+    try
+      {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        bencode(s, baos);
+        return baos.toByteArray();
+      }
+    catch (IOException ioe)
+      {
+        throw new InternalError(ioe.toString());
+      }
+  }
+
+  public static void bencode(String s, OutputStream out) throws IOException
+  {
+    byte[] bs = s.getBytes("UTF-8");
+    bencode(bs, out);
+  }
+
+  public static byte[] bencode(Number n)
+  {
+    try
+      {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        bencode(n, baos);
+        return baos.toByteArray();
+      }
+    catch (IOException ioe)
+      {
+        throw new InternalError(ioe.toString());
+      }
+  }
+
+  public static void bencode(Number n, OutputStream out) throws IOException
+  {
+    out.write('i');
+    String s = n.toString();
+    out.write(s.getBytes("UTF-8"));
+    out.write('e');
+  }
+
+  public static byte[] bencode(List l)
+  {
+    try
+      {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        bencode(l, baos);
+        return baos.toByteArray();
+      }
+    catch (IOException ioe)
+      {
+        throw new InternalError(ioe.toString());
+      }
+  }
+
+  public static void bencode(List l, OutputStream out) throws IOException
+  {
+    out.write('l');
+    Iterator it = l.iterator();
+    while (it.hasNext())
+      bencode(it.next(), out);
+    out.write('e');
+  }
+
+  public static byte[] bencode(byte[] bs)
+  {
+    try
+      {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        bencode(bs, baos);
+        return baos.toByteArray();
+      }
+    catch (IOException ioe)
+      {
+        throw new InternalError(ioe.toString());
+      }
+  }
+
+  public static void bencode(byte[] bs, OutputStream out) throws IOException
+  {
+    String l = Integer.toString(bs.length);
+    out.write(l.getBytes("UTF-8"));
+    out.write(':');
+    out.write(bs);
+  }
+
+  public static byte[] bencode(Map m)
+  {
+    try
+      {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        bencode(m, baos);
+        return baos.toByteArray();
+      }
+    catch (IOException ioe)
+      {
+        throw new InternalError(ioe.toString());
+      }
+  }
+
+  public static void bencode(Map m, OutputStream out) throws IOException
+  {
+    out.write('d');
+
+    // Keys must be sorted. XXX - But is this the correct order?
+    Set s = m.keySet();
+    List l = new ArrayList(s);
+    Collections.sort(l);
+
+    Iterator it = l.iterator();
+    while(it.hasNext())
+      {
+        // Keys must be Strings.
+        String key = (String)it.next();
+        Object value = m.get(key);
+        bencode(key, out);
+        bencode(value, out);
+      }
+
+    out.write('e');
+  }
+}

apps/i2psnark/java/src/org/klomp/snark/bencode/InvalidBEncodingException.java

@@ -0,0 +1,36 @@
+/* InvalidBEncodingException - Thrown when a bencoded stream is corrupted.
+   Copyright (C) 2003 Mark J. Wielaard
+
+   This file is part of Snark.
+   
+   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, 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.
+*/
+
+package org.klomp.snark.bencode;
+
+import java.io.IOException;
+
+/**
+ * Exception thrown when a bencoded stream is corrupted.
+ *
+ * @author Mark Wielaard (mark@klomp.org)
+ */
+public class InvalidBEncodingException extends IOException
+{
+  public InvalidBEncodingException(String message)
+  {
+    super(message);
+  }
+}