Ticket #1994: 1994.diff

File 1994.diff, 6.3 KB (added by lazygravy, 4 years ago)

Patch to fix it!

  • new file src/java/net/i2p/zzzot/BEncoder.java

    #
    # old_revision [785732f7da1f54b275ec3be3312db507e5357c4b]
    #
    # add_file "src/java/net/i2p/zzzot/BEncoder.java"
    #  content [2ffb85bd6085d938d31fa0373d2e37559d09b20f]
    # 
    # patch "src/jsp/scrape.jsp"
    #  from [d7c86f2112e9a4a09b203a189b6a054ce44d69d3]
    #    to [290849d3c4703a21293fcdbd742bcf5a3568d0d3]
    #
    ============================================================
    - +  
     1/* BDecoder - Converts an InputStream to BEValues.
     2   Copyright (C) 2003 Mark J. Wielaard
     3
     4   This file is part of Snark.
     5   
     6   This program is free software; you can redistribute it and/or modify
     7   it under the terms of the GNU General Public License as published by
     8   the Free Software Foundation; either version 2, or (at your option)
     9   any later version.
     10 
     11   This program is distributed in the hope that it will be useful,
     12   but WITHOUT ANY WARRANTY; without even the implied warranty of
     13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     14   GNU General Public License for more details.
     15 
     16   You should have received a copy of the GNU General Public License
     17   along with this program; if not, write to the Free Software Foundation,
     18   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
     19*/
     20
     21package net.i2p.zzzot;
     22
     23import java.io.ByteArrayOutputStream;
     24import java.io.IOException;
     25import java.io.OutputStream;
     26import java.util.ArrayList;
     27import java.util.Collections;
     28import java.util.Iterator;
     29import java.util.List;
     30import java.util.Map;
     31import java.util.Set;
     32
     33public class BEncoder
     34{
     35
     36  public static final String ENCODING = "ISO-8859-1";
     37
     38  public static byte[] bencode(Object o) throws IllegalArgumentException
     39  {
     40    try
     41      {
     42        ByteArrayOutputStream baos = new ByteArrayOutputStream();
     43        bencode(o, baos);
     44        return baos.toByteArray();
     45      }
     46    catch (IOException ioe)
     47      {
     48        throw new InternalError(ioe.toString());
     49      }
     50  }
     51
     52  public static void bencode(Object o, OutputStream out)
     53    throws IOException, IllegalArgumentException
     54  {
     55    if (o == null)
     56      throw new NullPointerException("Cannot bencode null");
     57    if (o instanceof String)
     58      bencode((String)o, out);
     59    else if (o instanceof byte[])
     60      bencode((byte[])o, out);
     61    else if (o instanceof Number)
     62      bencode((Number)o, out);
     63    else if (o instanceof List)
     64      bencode((List<?>)o, out);
     65    else if (o instanceof Map)
     66      bencode((Map<?, ?>)o, out);
     67        // XXX: DO NOT DO THIS?
     68    //else if (o instanceof BEValue)
     69      //bencode(((BEValue)o).getValue(), out);
     70    else
     71      throw new IllegalArgumentException("Cannot bencode: " + o.getClass());
     72  }
     73
     74  public static byte[] bencode(String s)
     75  {
     76    try
     77      {
     78        ByteArrayOutputStream baos = new ByteArrayOutputStream();
     79        bencode(s, baos);
     80        return baos.toByteArray();
     81      }
     82    catch (IOException ioe)
     83      {
     84        throw new InternalError(ioe.toString());
     85      }
     86  }
     87
     88  public static void bencode(String s, OutputStream out) throws IOException
     89  {
     90    byte[] bs = s.getBytes(ENCODING);
     91    bencode(bs, out);
     92  }
     93
     94  public static byte[] bencode(Number n)
     95  {
     96    try
     97      {
     98        ByteArrayOutputStream baos = new ByteArrayOutputStream();
     99        bencode(n, baos);
     100        return baos.toByteArray();
     101      }
     102    catch (IOException ioe)
     103      {
     104        throw new InternalError(ioe.toString());
     105      }
     106  }
     107
     108  public static void bencode(Number n, OutputStream out) throws IOException
     109  {
     110    out.write('i');
     111    String s = n.toString();
     112    out.write(s.getBytes(ENCODING));
     113    out.write('e');
     114  }
     115
     116  public static byte[] bencode(List<?> l)
     117  {
     118    try
     119      {
     120        ByteArrayOutputStream baos = new ByteArrayOutputStream();
     121        bencode(l, baos);
     122        return baos.toByteArray();
     123      }
     124    catch (IOException ioe)
     125      {
     126        throw new InternalError(ioe.toString());
     127      }
     128  }
     129
     130  public static void bencode(List<?> l, OutputStream out) throws IOException
     131  {
     132    out.write('l');
     133    Iterator<?> it = l.iterator();
     134    while (it.hasNext())
     135      bencode(it.next(), out);
     136    out.write('e');
     137  }
     138
     139  public static byte[] bencode(byte[] bs)
     140  {
     141    try
     142      {
     143        ByteArrayOutputStream baos = new ByteArrayOutputStream();
     144        bencode(bs, baos);
     145        return baos.toByteArray();
     146      }
     147    catch (IOException ioe)
     148      {
     149        throw new InternalError(ioe.toString());
     150      }
     151  }
     152
     153  public static void bencode(byte[] bs, OutputStream out) throws IOException
     154  {
     155    String l = Integer.toString(bs.length);
     156    out.write(l.getBytes(ENCODING));
     157    out.write(':');
     158    out.write(bs);
     159  }
     160
     161  public static byte[] bencode(Map<?, ?> m)
     162  {
     163    try
     164      {
     165        ByteArrayOutputStream baos = new ByteArrayOutputStream();
     166        bencode(m, baos);
     167        return baos.toByteArray();
     168      }
     169    catch (IOException ioe)
     170      {
     171        throw new InternalError(ioe.toString());
     172      }
     173  }
     174
     175  public static void bencode(Map<?, ?> m, OutputStream out)
     176    throws IOException, IllegalArgumentException
     177  {
     178    out.write('d');
     179
     180    // Keys must be sorted. XXX - But is this the correct order?
     181    Set<?> s = m.keySet();
     182    List<String> l = new ArrayList<String>(s.size());
     183    for (Object k : s) {
     184      // Keys must be Strings.
     185      if (String.class.isAssignableFrom(k.getClass()))
     186        l.add((String) k);
     187      else
     188        throw new IllegalArgumentException("Cannot bencode map: contains non-String key of type " + k.getClass());
     189    }
     190    Collections.sort(l);
     191
     192    Iterator<String> it = l.iterator();
     193    while(it.hasNext())
     194      {
     195        String key = it.next();
     196        bencode(key, out);
     197        bencode(m.get(key), out);
     198      }
     199
     200    out.write('e');
     201  }
     202}
     203
  • src/jsp/scrape.jsp

    ============================================================
     
    1 <%@page import="java.util.ArrayList,java.util.List,java.util.Map,java.util.HashMap,net.i2p.zzzot.*,org.klomp.snark.bencode.BEncoder" %><%
     1<%@page import="java.util.ArrayList,java.util.List,java.util.Map,java.util.HashMap,net.i2p.zzzot.*" %><%
    22
    33/*
    44 *  Above one-liner is so there is no whitespace -> IllegalStateException