Azureus源码剖析（二） ---解析Torrent种子文件

      BT种子文件使用了一种叫bencoding的编码方法来保存数据。

bencoding有四种类型的数据：srings(字符串)，integers(整数)，lists(列表)，dictionaries(字典)
编码规则如下：
(1)strings(字符串)编码为：<字符串长度>：<字符串>
例如： 4:test 表示为字符串"test"
 4:例子 表示为字符串“例子”
字符串长度单位为字节
没开始或结束标记

(2)integers(整数)编码为：i<整数>e
开始标记i，结束标记为e
例如： i1234e 表示为整数1234
 i-1234e 表示为整数-1234
整数没有大小限制
 i0e 表示为整数0
 i-0e 为非法
以0开头的为非法如： i01234e 为非法

(3)lists(列表)编码为：l<bencoding编码类型>e
开始标记为l,结束标记为e
列表里可以包含任何bencoding编码类型，包括整数，字符串，列表，字典。
例如： l4:test5:abcdee 表示为二个字符串["test","abcde"]

(4)dictionaries(字典)编码为d<bencoding字符串><bencoding编码类型>e
开始标记为d,结束标记为e
关键字必须为bencoding字符串
值可以为任何bencoding编码类型
例如： d3:agei20ee 表示为{"age"=20}
 d4:path3:C:"8:filename8:test.txte

 表示为{"path"="C:"","filename"="test.txt"}

(5)具体文件结构如下：
全部内容必须都为bencoding编码类型。
整个文件为一个字典结构,包含如下关键字
announce:tracker服务器的URL(字符串)
announce-list(可选):备用tracker服务器列表(列表)
creation date(可选):种子创建的时间，Unix标准时间格式，从1970 1月1日 00:00:00到创建时间的秒数(整数)
comment(可选):备注(字符串)
created by(可选):创建人或创建程序的信息(字符串)
info:一个字典结构，包含文件的主要信息，为分二种情况：单文件结构或多文件结构
单文件结构如下：
          length:文件长度，单位字节(整数)
          md5sum(可选)：长32个字符的文件的MD5校验和，BT不使用这个值，只是为了兼容一些程序所保留!(字符串)
          name:文件名(字符串)
          piece length:每个块的大小，单位字节(整数)
          pieces:每个块的20个字节的SHA1 Hash的值(二进制格式)
多文件结构如下：
          files:一个字典结构
                 length:文件长度，单位字节(整数)
                 md5sum(可选):同单文件结构中相同
                 path:文件的路径和名字，是一个列表结构，如"test"test.txt 列表为l4:test8test.txte
          name:最上层的目录名字(字符串)
          piece length:同单文件结构中相同
          pieces:同单文件结构中相同 
(6)实例：
用记事本打开一个.torrent可以看来类似如下内容
d8:announce35:http://www.manfen.net:7802/announce13:creation datei1076675108e4:infod6:lengthi17799e4:name62:MICROSOFT.WINDOWS.2000.AND.NT4.SOURCE.CODE-SCENELEADER.torrent12:piece lengthi32768e6:pieces20:?W ?躐?緕排T酆ee

很容易看出
announce＝http://www.manfen.net:7802/announce
creation date＝1076675108秒(02/13/04 20:25:08)
文件名=MICROSOFT.WINDOWS.2000.AND.NT4.SOURCE.CODE-SCENELEADER.torrent
文件大小＝17799字节
文件块大小＝32768字节

       对Azureus中解析Torrent种子文件的源代码进行了适度裁剪，得到下面这样一个解析torrent文件的示例代码，如下所示：

/*
 * BeDecoder.java
 *
  */

package  com.vista.test;

import  java.io. * ;
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.
 *
  */
public   class  BDecoder 
{
     // 字符集
     public   static   final  String BYTE_ENCODING  =   " UTF8 " ;
     public   static  Charset    BYTE_CHARSET;
     static
    {
         try
        {
            BYTE_CHARSET      =  Charset.forName(BYTE_ENCODING);
        }
         catch ( Throwable e )
        {
            e.printStackTrace();
        }
    }
     private   static   final   boolean  TRACE     =   true ;
    
     private   boolean  recovery_mode;

     public   static  Map decode(BufferedInputStream is)  throws  Exception
    { // 解码
         return (  new  BDecoder().decodeStream( is ));
    }
    
     public  BDecoder() 
    {    
    }
    
     public  Map decodeStream(BufferedInputStream data )  throws  Exception
    {
        Object    res  =  decodeInputStream( new  BDecoderInputStreamStream(data),  0 ); // 0指定递归层次从第一层开始
         if  ( res  ==   null  )
        {
             throw (  new  Exception(  " BDecoder: zero length file "  ));

        }
         else   if  (  ! (res  instanceof  Map ))
        {
             throw (  new  Exception(  " BDecoder: top level isn't a Map "  ));
        }
         return ((Map)res );
    }

     /**
     * 
     *  @param  dbis
     *  @param  nesting 递归层次
     *  @throws  Exception
      */
     private  Object decodeInputStream(BDecoderInputStream dbis, int  nesting )  throws  Exception 
    {
         if  (nesting  ==   0   &&   ! dbis.markSupported())
        {
             throw   new  IOException( " InputStream must support the mark() method " );
        }
         // set a mark
        dbis.mark(Integer.MAX_VALUE);

         // read a byte
         int  tempByte  =  dbis.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(dbis, nesting + 1 ))  !=   null )
                    {
                         // decode some more
                        Object value  =  decodeInputStream(dbis,nesting + 1 ); // 读值                
                         //  value interning is too CPU-intensive, let's skip that for now
                         // if(value instanceof byte[] && ((byte[])value).length < 17)
                         // value = StringInterner.internBytes((byte[])value);
                         //  keys often repeat a lot - intern to save space                
                        String    key  =   null ;
    
                         if  ( key  ==   null  )
                        {
                            CharBuffer    cb  =  BYTE_CHARSET.decode(ByteBuffer.wrap(tempByteArray));
                            key  =   new  String(cb.array(), 0 ,cb.limit()); // 键
                        }
                         if  ( TRACE )
                        {
                            System.out.println( key  +   " -> "   +  value  +   " ; "  );
                        }
                        
                             //  recover from some borked encodings that I have seen whereby the value has
                             //  not been encoded. This results in, for example, 
                             //  18:azureus_propertiesd0:e
                             //  we only get null back here if decoding has hit an 'e' or end-of-file
                             //  that is, there is no valid way for us to get a null 'value' here
                        
                         if  ( value  ==   null  )
                        {
                             // Debug.out( "Invalid encoding - value not serialsied for '" + key + "' - ignoring" );
                             break ;
                        }
                        tempMap.put( key, value); // 放入结果集中
                    }
    
                    dbis.mark(Integer.MAX_VALUE);
                    tempByte  =  dbis.read();
                    dbis.reset();
                     if  ( nesting  >   0   &&  tempByte  ==   - 1  )
                    {
                         throw (  new  Exception(  " 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.getMessage()));
                    }
                }
                 return  tempMap;
            }
         case   ' l '  :
        {
             // create the list
            ArrayList tempList  =   new  ArrayList();
             try
            {
                 // create the key
                Object tempElement  =   null ;
                 while  ((tempElement  =  decodeInputStream(dbis, nesting + 1 ))  !=   null )
                {
                     // add the element
                    tempList.add(tempElement); // 读取列表元素并加入列表中
                }

                tempList.trimToSize();
                dbis.mark(Integer.MAX_VALUE);
                tempByte  =  dbis.read();
                dbis.reset();
                 if  ( nesting  >   0   &&  tempByte  ==   - 1  )
                {
                     throw (  new  Exception(  " 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.getMessage()));
                }
            }
                 // return the list
             return  tempList;
        }
         case   ' e '  :
         case   - 1  :
             return   null ; // 当前结束

         case   ' i '  :
             return   new  Long(getNumberFromStream(dbis,  ' e ' )); // 整数

         case   ' 0 '  :
         case   ' 1 '  :
         case   ' 2 '  :
         case   ' 3 '  :
         case   ' 4 '  :
         case   ' 5 '  :
         case   ' 6 '  :
         case   ' 7 '  :
         case   ' 8 '  :
         case   ' 9 '  :
                 // move back one
            dbis.reset();
                 // get the string
             return  getByteArrayFromStream(dbis); // 读取指定长度字符串

         default  :
        {
             int     rem_len  =  dbis.available();
             if  ( rem_len  >   256  )
            {
                rem_len     =   256 ;
            }

             byte [] rem_data  =   new   byte [rem_len];
            dbis.read( rem_data );
             throw (  new  Exception( " BDecoder: unknown command ' "   +  tempByte  +   " , remainder =  "   +   new  String( rem_data )));
        }
        }
    }

     /**  only create the array once per decoder instance (no issues with recursion as it's only used in a leaf method)
      */
     private   final   char [] numberChars  =   new   char [ 32 ];
    
     private   long  getNumberFromStream(BDecoderInputStream dbis,  char  parseChar)  throws  IOException 
    {
         int  tempByte  =  dbis.read();
         int  pos  =   0 ;
         while  ((tempByte  !=  parseChar)  &&  (tempByte  >=   0 )) 
        { // 读取整数字节，直到终结字符'e'
            numberChars[pos ++ ]  =  ( char )tempByte;
             if  ( pos  ==  numberChars.length )
            {
                 throw (  new  NumberFormatException(  " Number too large:  "   +   new  String(numberChars, 0 ,pos)  +   " "  ));
            }
            tempByte  =  dbis.read();
        }

         // are we at the end of the stream?
         if  (tempByte  <   0 ) 
        {
             return   - 1 ;
        }
         else   if  ( pos  ==   0  )
        {
             //  support some borked impls that sometimes don't bother encoding anything
             return ( 0 );
        }
         return ( parseLong( numberChars,  0 , pos )); // 转换为Long型整数
    }

     public   static   long  parseLong( char []    chars, int  start, int     length )
    { // 转换为Long型整数
         long  result  =   0 ;
         boolean  negative  =   false ;
         int      i      =  start;
         int     max  =  start  +  length;
         long  limit;
         if  ( length  >   0  )
        {
             if  ( chars[i]  ==   ' - '  )
            {
                negative  =   true ;
                limit  =  Long.MIN_VALUE;
                i ++ ;
            }
             else
            {
                limit  =   - Long.MAX_VALUE;
            }

             if  ( i  <  max )
            {
                 int  digit  =  chars[i ++ ]  -   ' 0 ' ;
                 if  ( digit  <   0   ||  digit  >   9  )
                {
                     throw   new  NumberFormatException( new  String(chars,start,length));
                }
                 else
                {
                    result  =   - digit;
                }
            }

             long  multmin  =  limit  /   10 ;

             while  ( i  <  max )
            {
                 //  Accumulating negatively avoids surprises near MAX_VALUE
                 int  digit  =  chars[i ++ ]  -   ' 0 ' ;
                 if  ( digit  <   0   ||  digit  >   9  )
                {
                     throw   new  NumberFormatException( new  String(chars,start,length));
                }
                 if  ( result  <  multmin )
                {
                     throw   new  NumberFormatException( new  String(chars,start,length));
                }
                result  *=   10 ;
                 if  ( result  <  limit  +  digit )
                {
                     throw   new  NumberFormatException( new  String(chars,start,length));
                }

                result  -=  digit;
            }
        }
         else
        {
             throw   new  NumberFormatException( new  String(chars,start,length));
        }

         if  ( negative )
        {
             if  ( i  >  start + 1  )
            {
                 return  result;

            }
             else
            {     /*  Only got "-"  */
                 throw   new  NumberFormatException( new  String(chars,start,length));
            }
        }
         else
        {
             return   - result;
        }  
    }

     private   byte [] getByteArrayFromStream(BDecoderInputStream dbis )  throws  IOException 
    {
         int  length  =  ( int ) getNumberFromStream(dbis,  ' : ' );
         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  =  dbis.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;
    }
    
     public   static   void  print(PrintWriter writer,Object obj )
    {
        print( writer, obj,  "" ,  false  );
    }

     private   static   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  +   "  {  " +  ByteFormatter.nicePrint( b ) +   "  } "  );
            }
             else   if  ( b.length  <   64  )
            {
                writer.println(  new  String(b)  +   "  [ "   +  ByteFormatter.encodeString( b )  +   " ] "  );
            } 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(); // 解码器
            PrintWriter    pw  =   new  PrintWriter(  new  FileWriter( output )); // 输出结果
            print( pw, decoder.decodeStream(  new  BufferedInputStream(  new  FileInputStream( f ))));
            pw.flush();
        }
         catch ( Throwable e )
        {
            e.printStackTrace();
        }
    }

     private   interface  BDecoderInputStream
    {
         public   int  read()  throws  IOException;
         public   int  read( byte [] buffer) throws  IOException;
         public   int  read( byte []     buffer, int     offset, int     length ) throws  IOException;
         public   int  available() throws  IOException;
         public   boolean  markSupported();
         public   void  mark( int  limit );
         public   void  reset()  throws  IOException;
    }

     private   class  BDecoderInputStreamStream  implements  BDecoderInputStream
    {
         final   private  BufferedInputStream is;
         private  BDecoderInputStreamStream(BufferedInputStream _is )
        {
            is     =  _is;
        }
         /**
         * 从此输入流中读取下一个数据字节。返回一个 0 到 255 范围内的 int 字节值。
         * 如果因为已经到达流末尾而没有字节可用，则返回 -1。
         * 在输入数据可用、检测到流末尾或抛出异常之前，此方法将一直阻塞。 
          */
         public   int  read() throws  IOException
        {
             return ( is.read());
        }
         /**
         * 从此输入流中将 byte.length 个字节的数据读入一个 byte 数组中。在某些输入可用之前，此方法将阻塞。 
          */
         public   int  read( byte [] buffer ) throws  IOException
        {
             return ( is.read( buffer ));
        }
         /**
         * 从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。
          */
         public   int  read( byte []     buffer, int     offset, int     length) throws  IOException
        {
             return ( is.read( buffer, offset, length ));  
        }
         /**
         * 返回可以从此输入流读取（或跳过）、且不受此输入流接下来的方法调用阻塞的估计字节数。
          */
         public   int  available()  throws  IOException
        {
             return ( is.available());
        }

         /**
         * 测试此输入流是否支持 mark 和 reset 方法。
          */
         public   boolean  markSupported()
        {
             return ( is.markSupported());
        }

         /**
         * 在输入流中的当前位置上作标记。reset 方法的后续调用将此流重新定位在最后标记的位置上，以便后续读取操作重新读取相同的字节。
         *  @param  limit 在标记位置变为无效之前可以读取字节的最大限制。
          */
         public   void  mark( int  limit )
        {
            is.mark( limit );
        }
         /**
         * 将此流重新定位到对此输入流最后调用 mark 方法时的位置。
          */
         public   void  reset() throws  IOException
        {
            is.reset();
        }
    }

     public   static   void  main(String[]    args )
    {      
        print( new  File(  " C:\\1001.torrent "  ), new  File(  " C:\\tables.txt "  ));
    }
}