Low level proxy support added, MAC address spoofing done, basic runtime interception done

Signed-off-by: matt123337 <matt123337@hotmail.com>

.gitignore

@@ -46,3 +46,9 @@ parabotv2/src/META-INF/MANIFEST.MF
 /bin
 
 .idea/uiDesigner.xml
+
+*.jar
+
+*.classpath
+
+*.project

parabotv2/src/org/matt123337/proxy/ClassRemapper.java

@@ -0,0 +1,24 @@
+package org.matt123337.proxy;
+
+import java.util.HashMap;
+
+import org.objectweb.asm.commons.Remapper;
+
+public class ClassRemapper extends Remapper {
+	private static HashMap<String, String> remapNames = new HashMap<String, String>();
+	static {
+		remapNames.put("java/net/Socket", "org/matt123337/proxy/ProxySocket");
+		remapNames.put("java/net/NetworkInterface", "org/matt123337/spoofer/NetworkInterface");
+		remapNames.put("java/lang/Runtime", "org/matt123337/spoofer/Runtime");
+	}
+
+	@Override
+	public String map(String str) {
+		String s = remapNames.get(str);
+		if (s != null) {
+			return s;
+		} else {
+			return str;
+		}
+	}
+}

parabotv2/src/org/matt123337/proxy/ProxySocket.java

@@ -0,0 +1,276 @@
+package org.matt123337.proxy;
+
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.SocketAddress;
+import java.net.UnknownHostException;
+import java.nio.channels.SocketChannel;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.JOptionPane;
+
+import org.parabot.core.ui.components.LogArea;
+import org.parabot.core.ui.utils.UILog;
+
+public class ProxySocket extends Socket {
+	
+	private static List<ProxySocket>connections = new ArrayList<ProxySocket>();
+
+	private static ProxyType proxyType = ProxyType.HTTP;
+
+	private static int proxyPort = 0;
+
+	private InetAddress addr;
+	private int port;
+
+	private static InetAddress proxyInetAddress = null;
+
+	private InetSocketAddress cachedAddr;
+	
+	public static int closeConnections(){
+		int value = 0;
+		for(ProxySocket socket : connections)
+		try{
+			connections.remove(socket);
+			if(socket.isClosed())
+				continue;
+			socket.close();
+				value++;
+		}catch(Exception e){
+			
+		}
+		return value;
+	}
+
+	public ProxySocket(InetAddress addr, int port) throws IOException {
+		super(addr, port);
+	}
+
+	public ProxySocket() {
+		super();
+	}
+
+	public ProxySocket(String host, int port) throws IOException {
+		super(host, port);
+	}
+
+	public static void setProxy(ProxyType type,String host, int port) {
+		try {
+			proxyInetAddress = InetAddress.getByName(host);
+			proxyPort = port;
+			proxyType = type;
+		} catch (UnknownHostException e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	public static InetAddress getProxyAddress(){
+		return proxyInetAddress;
+	}
+	
+	public static int getProxyPort(){
+		return proxyPort;
+	}
+	
+	public static ProxyType getProxyType(){
+		return proxyType;
+	}
+
+	@Override
+	public void connect(SocketAddress addr) throws IOException {
+		connections.add(this);
+		if (addr instanceof InetSocketAddress) {
+			InetSocketAddress isa = (InetSocketAddress) addr;
+			this.addr = InetAddress.getByName(isa.getHostString());
+			this.port = isa.getPort();
+		}
+		if (proxyInetAddress != null && proxyPort > 0) {
+			try{
+			super.connect(cachedAddr = new InetSocketAddress(proxyInetAddress,
+					proxyPort));
+			initProxy();
+			}catch(Exception e){
+				UILog.log(
+						"Proxy Error",
+						e.getMessage(),
+						JOptionPane.ERROR_MESSAGE);
+			}
+		} else
+			super.connect(addr);
+	}
+
+	private void initProxy() throws IOException {
+		LogArea.log("Proxying:" + addr + ":" + port
+				+ " Over:" + proxyInetAddress + ":" + proxyPort + " Type:"
+				+ proxyType);
+		switch (proxyType) {
+		case HTTP:
+			http_connect();
+			break;
+		case SOCKS4:
+			socks4_connect();
+			break;
+		case SOCKS5:
+			socks5_connect();
+			break;
+		default:
+			throw new IOException("Unsupported proxy type:" + proxyType);
+		}
+	}
+
+	private void http_connect() throws IOException {
+		InputStream in = getInputStream();
+		BufferedReader br = new BufferedReader(new InputStreamReader(in));
+		OutputStream out = getOutputStream();
+		out.write(("CONNECT " + addr.getHostAddress() + ":" + port + "\r\n")
+				.getBytes());
+		// out.write("Connection:keep-alive\r\n".getBytes());
+		out.write("\r\n".getBytes());
+		String str;
+		while ((str = br.readLine()) != null) {
+			if (str.length() == 0)
+				break;
+			if (!str.startsWith("HTTP"))
+				continue;
+			int code = Integer.parseInt(str.substring(9, 12));
+			switch (code) {
+			case 404:
+				throw new IOException(
+						"Proxy seems to think we're connecting to a webpage...");
+			case 403:
+				throw new IOException(
+						"Proxy doesn't support connecting to port: " + port + "! Try a different proxy.");
+			}
+			if (code / 100 != 2)
+				throw new IOException(
+						"Unable to connect to proxy server! HTTP Error code:" + code);
+		}
+	}
+
+	private void socks4_connect() throws IOException {
+		DataOutputStream out = new DataOutputStream(getOutputStream());
+		DataInputStream in = new DataInputStream(getInputStream());
+
+		out.write(0x04);
+		out.write(0x01); // connection type (TCP stream)
+		out.writeShort(port);
+		byte[] b = addr.getAddress();
+		if (b.length != 4)
+			throw new IOException("Unsupported IP type for socksv4!");
+		out.write(b);
+		out.write(0); // the userID stuff, 0 means end of string (null
+						// terminated)
+		out.flush();
+
+		if (in.read() != 0x00) // null byte
+			throw new IOException("Proxy server dun goofed");
+		if (in.read() != 0x5a)
+			throw new IOException(
+					"Proxy server was unable to connect to server!");
+
+		in.readShort(); // ignored
+		in.readFully(b); // ignored
+	}
+
+	private void socks5_connect() throws IOException {
+		DataOutputStream out = new DataOutputStream(getOutputStream());
+		DataInputStream in = new DataInputStream(getInputStream());
+		out.write(0x05); // the version
+		out.write(1); // number of authentication methods (no auth for now)
+		out.write(0); // the authentication (none)
+		out.flush();
+
+		if (in.read() != 0x05) // remote proxy version
+			throw new IOException("Proxy server is not supported!");
+		if (in.read() != 0x00) // make sure shit is a vaild request
+			throw new IOException("Proxy server declined request!");
+
+		// now to write the actual request
+		out.write(0x05); // again the socks version
+		out.write(0x01); // the connection type (0x01 = TCP Connection)
+		out.write(0x00); // the reserve byte, un-used
+		byte[] b = addr.getAddress();
+		out.write(b.length == 4 ? 0x01 : 0x04); // if ipv4 or ipv6 (0x03 =
+												// domain name, but that's
+												// unsupported as of yet)
+		out.write(b);
+		out.writeShort(port);
+		out.flush();
+
+		// now to read the server's reply
+		if (in.read() != 0x05) // socks version (again)
+			throw new IOException("Proxy server dun goofed");
+		int reply = in.read();
+		if (reply == 0x08)
+			throw new IOException("Bad address sent to proxy server");
+		if (reply != 0x00)
+			throw new IOException("Unable to connect to server!");
+		in.read(); // reserve byte
+		int addrType = in.read();
+		b = new byte[4];
+		switch (addrType) {
+		case 0x01:
+			b = new byte[4];
+			break;
+		case 0x04:
+			b = new byte[16];
+			break;
+		default:
+			throw new IOException("Bad address type from proxy server!");
+		}
+		in.readFully(b);
+		in.readShort(); // the returned port #, ignored
+	}
+
+	@Override
+	public int getPort() {
+		if (super.getInetAddress().equals(proxyInetAddress))
+			return port;
+		return super.getPort();
+	}
+
+	@Override
+	public InetAddress getInetAddress() {
+		if (super.getInetAddress().equals(proxyInetAddress))
+			return addr;
+		return super.getInetAddress();
+	}
+
+	@Override
+	public SocketAddress getRemoteSocketAddress() {
+		if (super.getInetAddress().equals(proxyInetAddress))
+			return cachedAddr;
+		return super.getRemoteSocketAddress();
+	}
+
+	@Override
+	public SocketChannel getChannel() {
+		if (super.getInetAddress().equals(proxyInetAddress))
+			return null;
+		return super.getChannel();
+	}
+	
+	@Override
+	public void close() throws IOException{
+		connections.remove(this);
+		super.close();
+	}
+
+	public static void setType(ProxyType pt) {
+		proxyType = pt;
+	}
+
+	public static int getConnectionCount() {
+		return connections.size();
+	}
+
+}

parabotv2/src/org/matt123337/proxy/ProxyType.java

@@ -0,0 +1,5 @@
+package org.matt123337.proxy;
+
+public enum ProxyType {
+	SOCKS5,SOCKS4,HTTP
+}

parabotv2/src/org/matt123337/spoofer/NetworkInterface.java

@@ -0,0 +1,51 @@
+package org.matt123337.spoofer;
+
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.util.Enumeration;
+
+import org.parabot.core.ui.components.LogArea;
+
+public class NetworkInterface {
+
+	public static byte[] mac = new byte[] { 11, 11, 11, 11, 11, 11 };
+
+	private static byte[] realMac;
+
+	private static NetworkInterface cached;
+
+	static {
+		try {
+			mac = getRealHardwareAddress();
+		} catch (Exception ignored) {
+		}
+	}
+
+	public byte[] getHardwareAddress() {
+		return mac;
+	}
+
+	public static byte[] getRealHardwareAddress() throws SocketException {
+		if (realMac != null)
+			return realMac;
+		Enumeration<java.net.NetworkInterface> nis = java.net.NetworkInterface
+				.getNetworkInterfaces();
+		while (nis.hasMoreElements()) {
+			try {
+				byte[] b = nis.nextElement().getHardwareAddress();
+				if (b.length == 0)
+					continue;
+				return realMac = b;
+			} catch (Exception e) {
+			}
+		}
+		return mac;
+	}
+
+	public static NetworkInterface getByInetAddress(InetAddress addr) {
+		if (cached == null)
+			cached = new NetworkInterface();
+		return cached;
+	}
+
+}

parabotv2/src/org/matt123337/spoofer/Runtime.java

@@ -0,0 +1,64 @@
+package org.matt123337.spoofer;
+
+import java.io.IOException;
+
+import org.parabot.core.ui.components.LogArea;
+
+public class Runtime {
+	
+	private java.lang.Runtime rt;
+	
+	private static Runtime cached;
+	
+	private Runtime(java.lang.Runtime rt){
+		this.rt = rt;
+	}
+	
+	
+	public void addShutdownHook(Thread t){
+		rt.addShutdownHook(t);
+	}
+	
+	public int availableProcessors(){
+		return rt.availableProcessors();
+	}
+	
+	public void exit(int i){
+		rt.exit(i);
+	}
+	
+	public Process exec(String str) throws IOException{
+		LogArea.log("RT:" + str);
+		System.out.println("RT:" + str);
+		return rt.exec(str);
+	}
+	
+	public Process exec(String[] cmdarray) throws IOException{
+		StringBuffer sb = new StringBuffer();
+		for(int i = 0; i < cmdarray.length;i++){
+			sb.append(cmdarray[i] + (i < cmdarray.length - 1 ? "," : ""));
+		}
+		LogArea.log("RT: {" + sb + "}");
+		System.out.println("RT: {" + sb + "}");
+		return rt.exec(cmdarray);
+	}
+	
+	public long freeMemory(){
+		return rt.freeMemory();
+	}
+	
+	public void gc(){
+		rt.gc();
+	}
+	
+	public long maxMemory(){
+		return rt.maxMemory();
+	}
+	
+	public static Runtime getRuntime(){
+		if(cached == null)
+			cached = new Runtime(java.lang.Runtime.getRuntime());
+		return cached;
+	}
+
+}

parabotv2/src/org/objectweb/asm/commons/LocalVariablesSorter.java

@@ -0,0 +1,376 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.objectweb.asm.commons;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.TypePath;
+
+/**
+ * A {@link MethodVisitor} that renumbers local variables in their order of
+ * appearance. This adapter allows one to easily add new local variables to a
+ * method. It may be used by inheriting from this class, but the preferred way
+ * of using it is via delegation: the next visitor in the chain can indeed add
+ * new locals when needed by calling {@link #newLocal} on this adapter (this
+ * requires a reference back to this {@link LocalVariablesSorter}).
+ * 
+ * @author Chris Nokleberg
+ * @author Eugene Kuleshov
+ * @author Eric Bruneton
+ */
+public class LocalVariablesSorter extends MethodVisitor {
+
+    private static final Type OBJECT_TYPE = Type
+            .getObjectType("java/lang/Object");
+
+    /**
+     * Mapping from old to new local variable indexes. A local variable at index
+     * i of size 1 is remapped to 'mapping[2*i]', while a local variable at
+     * index i of size 2 is remapped to 'mapping[2*i+1]'.
+     */
+    private int[] mapping = new int[40];
+
+    /**
+     * Array used to store stack map local variable types after remapping.
+     */
+    private Object[] newLocals = new Object[20];
+
+    /**
+     * Index of the first local variable, after formal parameters.
+     */
+    protected final int firstLocal;
+
+    /**
+     * Index of the next local variable to be created by {@link #newLocal}.
+     */
+    protected int nextLocal;
+
+    /**
+     * Indicates if at least one local variable has moved due to remapping.
+     */
+    private boolean changed;
+
+    /**
+     * Creates a new {@link LocalVariablesSorter}. <i>Subclasses must not use
+     * this constructor</i>. Instead, they must use the
+     * {@link #LocalVariablesSorter(int, int, String, MethodVisitor)} version.
+     * 
+     * @param access
+     *            access flags of the adapted method.
+     * @param desc
+     *            the method's descriptor (see {@link Type Type}).
+     * @param mv
+     *            the method visitor to which this adapter delegates calls.
+     */
+    public LocalVariablesSorter(final int access, final String desc,
+            final MethodVisitor mv) {
+        this(Opcodes.ASM5, access, desc, mv);
+    }
+
+    /**
+     * Creates a new {@link LocalVariablesSorter}.
+     * 
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}.
+     * @param access
+     *            access flags of the adapted method.
+     * @param desc
+     *            the method's descriptor (see {@link Type Type}).
+     * @param mv
+     *            the method visitor to which this adapter delegates calls.
+     */
+    protected LocalVariablesSorter(final int api, final int access,
+            final String desc, final MethodVisitor mv) {
+        super(api, mv);
+        Type[] args = Type.getArgumentTypes(desc);
+        nextLocal = (Opcodes.ACC_STATIC & access) == 0 ? 1 : 0;
+        for (int i = 0; i < args.length; i++) {
+            nextLocal += args[i].getSize();
+        }
+        firstLocal = nextLocal;
+    }
+
+    @Override
+    public void visitVarInsn(final int opcode, final int var) {
+        Type type;
+        switch (opcode) {
+        case Opcodes.LLOAD:
+        case Opcodes.LSTORE:
+            type = Type.LONG_TYPE;
+            break;
+
+        case Opcodes.DLOAD:
+        case Opcodes.DSTORE:
+            type = Type.DOUBLE_TYPE;
+            break;
+
+        case Opcodes.FLOAD:
+        case Opcodes.FSTORE:
+            type = Type.FLOAT_TYPE;
+            break;
+
+        case Opcodes.ILOAD:
+        case Opcodes.ISTORE:
+            type = Type.INT_TYPE;
+            break;
+
+        default:
+            // case Opcodes.ALOAD:
+            // case Opcodes.ASTORE:
+            // case RET:
+            type = OBJECT_TYPE;
+            break;
+        }
+        mv.visitVarInsn(opcode, remap(var, type));
+    }
+
+    @Override
+    public void visitIincInsn(final int var, final int increment) {
+        mv.visitIincInsn(remap(var, Type.INT_TYPE), increment);
+    }
+
+    @Override
+    public void visitMaxs(final int maxStack, final int maxLocals) {
+        mv.visitMaxs(maxStack, nextLocal);
+    }
+
+    @Override
+    public void visitLocalVariable(final String name, final String desc,
+            final String signature, final Label start, final Label end,
+            final int index) {
+        int newIndex = remap(index, Type.getType(desc));
+        mv.visitLocalVariable(name, desc, signature, start, end, newIndex);
+    }
+
+    @Override
+    public AnnotationVisitor visitLocalVariableAnnotation(int typeRef,
+            TypePath typePath, Label[] start, Label[] end, int[] index,
+            String desc, boolean visible) {
+        Type t = Type.getType(desc);
+        int[] newIndex = new int[index.length];
+        for (int i = 0; i < newIndex.length; ++i) {
+            newIndex[i] = remap(index[i], t);
+        }
+        return mv.visitLocalVariableAnnotation(typeRef, typePath, start, end,
+                newIndex, desc, visible);
+    }
+
+    @Override
+    public void visitFrame(final int type, final int nLocal,
+            final Object[] local, final int nStack, final Object[] stack) {
+        if (type != Opcodes.F_NEW) { // uncompressed frame
+            throw new IllegalStateException(
+                    "ClassReader.accept() should be called with EXPAND_FRAMES flag");
+        }
+
+        if (!changed) { // optimization for the case where mapping = identity
+            mv.visitFrame(type, nLocal, local, nStack, stack);
+            return;
+        }
+
+        // creates a copy of newLocals
+        Object[] oldLocals = new Object[newLocals.length];
+        System.arraycopy(newLocals, 0, oldLocals, 0, oldLocals.length);
+
+        updateNewLocals(newLocals);
+
+        // copies types from 'local' to 'newLocals'
+        // 'newLocals' already contains the variables added with 'newLocal'
+
+        int index = 0; // old local variable index
+        int number = 0; // old local variable number
+        for (; number < nLocal; ++number) {
+            Object t = local[number];
+            int size = t == Opcodes.LONG || t == Opcodes.DOUBLE ? 2 : 1;
+            if (t != Opcodes.TOP) {
+                Type typ = OBJECT_TYPE;
+                if (t == Opcodes.INTEGER) {
+                    typ = Type.INT_TYPE;
+                } else if (t == Opcodes.FLOAT) {
+                    typ = Type.FLOAT_TYPE;
+                } else if (t == Opcodes.LONG) {
+                    typ = Type.LONG_TYPE;
+                } else if (t == Opcodes.DOUBLE) {
+                    typ = Type.DOUBLE_TYPE;
+                } else if (t instanceof String) {
+                    typ = Type.getObjectType((String) t);
+                }
+                setFrameLocal(remap(index, typ), t);
+            }
+            index += size;
+        }
+
+        // removes TOP after long and double types as well as trailing TOPs
+
+        index = 0;
+        number = 0;
+        for (int i = 0; index < newLocals.length; ++i) {
+            Object t = newLocals[index++];
+            if (t != null && t != Opcodes.TOP) {
+                newLocals[i] = t;
+                number = i + 1;
+                if (t == Opcodes.LONG || t == Opcodes.DOUBLE) {
+                    index += 1;
+                }
+            } else {
+                newLocals[i] = Opcodes.TOP;
+            }
+        }
+
+        // visits remapped frame
+        mv.visitFrame(type, number, newLocals, nStack, stack);
+
+        // restores original value of 'newLocals'
+        newLocals = oldLocals;
+    }
+
+    // -------------
+
+    /**
+     * Creates a new local variable of the given type.
+     * 
+     * @param type
+     *            the type of the local variable to be created.
+     * @return the identifier of the newly created local variable.
+     */
+    public int newLocal(final Type type) {
+        Object t;
+        switch (type.getSort()) {
+        case Type.BOOLEAN:
+        case Type.CHAR:
+        case Type.BYTE:
+        case Type.SHORT:
+        case Type.INT:
+            t = Opcodes.INTEGER;
+            break;
+        case Type.FLOAT:
+            t = Opcodes.FLOAT;
+            break;
+        case Type.LONG:
+            t = Opcodes.LONG;
+            break;
+        case Type.DOUBLE:
+            t = Opcodes.DOUBLE;
+            break;
+        case Type.ARRAY:
+            t = type.getDescriptor();
+            break;
+        // case Type.OBJECT:
+        default:
+            t = type.getInternalName();
+            break;
+        }
+        int local = newLocalMapping(type);
+        setLocalType(local, type);
+        setFrameLocal(local, t);
+        changed = true;
+        return local;
+    }
+
+    /**
+     * Notifies subclasses that a new stack map frame is being visited. The
+     * array argument contains the stack map frame types corresponding to the
+     * local variables added with {@link #newLocal}. This method can update
+     * these types in place for the stack map frame being visited. The default
+     * implementation of this method does nothing, i.e. a local variable added
+     * with {@link #newLocal} will have the same type in all stack map frames.
+     * But this behavior is not always the desired one, for instance if a local
+     * variable is added in the middle of a try/catch block: the frame for the
+     * exception handler should have a TOP type for this new local.
+     * 
+     * @param newLocals
+     *            the stack map frame types corresponding to the local variables
+     *            added with {@link #newLocal} (and null for the others). The
+     *            format of this array is the same as in
+     *            {@link MethodVisitor#visitFrame}, except that long and double
+     *            types use two slots. The types for the current stack map frame
+     *            must be updated in place in this array.
+     */
+    protected void updateNewLocals(Object[] newLocals) {
+    }
+
+    /**
+     * Notifies subclasses that a local variable has been added or remapped. The
+     * default implementation of this method does nothing.
+     * 
+     * @param local
+     *            a local variable identifier, as returned by {@link #newLocal
+     *            newLocal()}.
+     * @param type
+     *            the type of the value being stored in the local variable.
+     */
+    protected void setLocalType(final int local, final Type type) {
+    }
+
+    private void setFrameLocal(final int local, final Object type) {
+        int l = newLocals.length;
+        if (local >= l) {
+            Object[] a = new Object[Math.max(2 * l, local + 1)];
+            System.arraycopy(newLocals, 0, a, 0, l);
+            newLocals = a;
+        }
+        newLocals[local] = type;
+    }
+
+    private int remap(final int var, final Type type) {
+        if (var + type.getSize() <= firstLocal) {
+            return var;
+        }
+        int key = 2 * var + type.getSize() - 1;
+        int size = mapping.length;
+        if (key >= size) {
+            int[] newMapping = new int[Math.max(2 * size, key + 1)];
+            System.arraycopy(mapping, 0, newMapping, 0, size);
+            mapping = newMapping;
+        }
+        int value = mapping[key];
+        if (value == 0) {
+            value = newLocalMapping(type);
+            setLocalType(value, type);
+            mapping[key] = value + 1;
+        } else {
+            value--;
+        }
+        if (value != var) {
+            changed = true;
+        }
+        return value;
+    }
+
+    protected int newLocalMapping(final Type type) {
+        int local = nextLocal;
+        nextLocal += type.getSize();
+        return local;
+    }
+}

parabotv2/src/org/objectweb/asm/commons/Remapper.java

@@ -0,0 +1,223 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.objectweb.asm.commons;
+
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.signature.SignatureReader;
+import org.objectweb.asm.signature.SignatureVisitor;
+import org.objectweb.asm.signature.SignatureWriter;
+
+/**
+ * A class responsible for remapping types and names. Subclasses can override
+ * the following methods:
+ * 
+ * <ul>
+ * <li>{@link #map(String)} - map type</li>
+ * <li>{@link #mapFieldName(String, String, String)} - map field name</li>
+ * <li>{@link #mapMethodName(String, String, String)} - map method name</li>
+ * </ul>
+ * 
+ * @author Eugene Kuleshov
+ */
+public abstract class Remapper {
+
+    public String mapDesc(String desc) {
+        Type t = Type.getType(desc);
+        switch (t.getSort()) {
+        case Type.ARRAY:
+            String s = mapDesc(t.getElementType().getDescriptor());
+            for (int i = 0; i < t.getDimensions(); ++i) {
+                s = '[' + s;
+            }
+            return s;
+        case Type.OBJECT:
+            String newType = map(t.getInternalName());
+            if (newType != null) {
+                return 'L' + newType + ';';
+            }
+        }
+        return desc;
+    }
+
+    private Type mapType(Type t) {
+        switch (t.getSort()) {
+        case Type.ARRAY:
+            String s = mapDesc(t.getElementType().getDescriptor());
+            for (int i = 0; i < t.getDimensions(); ++i) {
+                s = '[' + s;
+            }
+            return Type.getType(s);
+        case Type.OBJECT:
+            s = map(t.getInternalName());
+            return s != null ? Type.getObjectType(s) : t;
+        case Type.METHOD:
+            return Type.getMethodType(mapMethodDesc(t.getDescriptor()));
+        }
+        return t;
+    }
+
+    public String mapType(String type) {
+        if (type == null) {
+            return null;
+        }
+        return mapType(Type.getObjectType(type)).getInternalName();
+    }
+
+    public String[] mapTypes(String[] types) {
+        String[] newTypes = null;
+        boolean needMapping = false;
+        for (int i = 0; i < types.length; i++) {
+            String type = types[i];
+            String newType = map(type);
+            if (newType != null && newTypes == null) {
+                newTypes = new String[types.length];
+                if (i > 0) {
+                    System.arraycopy(types, 0, newTypes, 0, i);
+                }
+                needMapping = true;
+            }
+            if (needMapping) {
+                newTypes[i] = newType == null ? type : newType;
+            }
+        }
+        return needMapping ? newTypes : types;
+    }
+
+    public String mapMethodDesc(String desc) {
+        if ("()V".equals(desc)) {
+            return desc;
+        }
+
+        Type[] args = Type.getArgumentTypes(desc);
+        StringBuffer s = new StringBuffer("(");
+        for (int i = 0; i < args.length; i++) {
+            s.append(mapDesc(args[i].getDescriptor()));
+        }
+        Type returnType = Type.getReturnType(desc);
+        if (returnType == Type.VOID_TYPE) {
+            s.append(")V");
+            return s.toString();
+        }
+        s.append(')').append(mapDesc(returnType.getDescriptor()));
+        return s.toString();
+    }
+
+    public Object mapValue(Object value) {
+        if (value instanceof Type) {
+            return mapType((Type) value);
+        }
+        if (value instanceof Handle) {
+            Handle h = (Handle) value;
+            return new Handle(h.getTag(), mapType(h.getOwner()), mapMethodName(
+                    h.getOwner(), h.getName(), h.getDesc()),
+                    mapMethodDesc(h.getDesc()));
+        }
+        return value;
+    }
+
+    /**
+     * 
+     * @param typeSignature
+     *            true if signature is a FieldTypeSignature, such as the
+     *            signature parameter of the ClassVisitor.visitField or
+     *            MethodVisitor.visitLocalVariable methods
+     */
+    public String mapSignature(String signature, boolean typeSignature) {
+        if (signature == null) {
+            return null;
+        }
+        SignatureReader r = new SignatureReader(signature);
+        SignatureWriter w = new SignatureWriter();
+        SignatureVisitor a = createRemappingSignatureAdapter(w);
+        if (typeSignature) {
+            r.acceptType(a);
+        } else {
+            r.accept(a);
+        }
+        return w.toString();
+    }
+
+    protected SignatureVisitor createRemappingSignatureAdapter(
+            SignatureVisitor v) {
+        return new RemappingSignatureAdapter(v, this);
+    }
+
+    /**
+     * Map method name to the new name. Subclasses can override.
+     * 
+     * @param owner
+     *            owner of the method.
+     * @param name
+     *            name of the method.
+     * @param desc
+     *            descriptor of the method.
+     * @return new name of the method
+     */
+    public String mapMethodName(String owner, String name, String desc) {
+        return name;
+    }
+
+    /**
+     * Map invokedynamic method name to the new name. Subclasses can override.
+     * 
+     * @param name
+     *            name of the invokedynamic.
+     * @param desc
+     *            descriptor of the invokedynamic.
+     * @return new invokdynamic name.
+     */
+    public String mapInvokeDynamicMethodName(String name, String desc) {
+        return name;
+    }
+
+    /**
+     * Map field name to the new name. Subclasses can override.
+     * 
+     * @param owner
+     *            owner of the field.
+     * @param name
+     *            name of the field
+     * @param desc
+     *            descriptor of the field
+     * @return new name of the field.
+     */
+    public String mapFieldName(String owner, String name, String desc) {
+        return name;
+    }
+
+    /**
+     * Map type name to the new name. Subclasses can override.
+     */
+    public String map(String typeName) {
+        return typeName;
+    }
+}

parabotv2/src/org/objectweb/asm/commons/RemappingAnnotationAdapter.java

@@ -0,0 +1,79 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.objectweb.asm.commons;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * An {@link AnnotationVisitor} adapter for type remapping.
+ * 
+ * @author Eugene Kuleshov
+ */
+public class RemappingAnnotationAdapter extends AnnotationVisitor {
+
+    protected final Remapper remapper;
+
+    public RemappingAnnotationAdapter(final AnnotationVisitor av,
+            final Remapper remapper) {
+        this(Opcodes.ASM5, av, remapper);
+    }
+
+    protected RemappingAnnotationAdapter(final int api,
+            final AnnotationVisitor av, final Remapper remapper) {
+        super(api, av);
+        this.remapper = remapper;
+    }
+
+    @Override
+    public void visit(String name, Object value) {
+        av.visit(name, remapper.mapValue(value));
+    }
+
+    @Override
+    public void visitEnum(String name, String desc, String value) {
+        av.visitEnum(name, remapper.mapDesc(desc), value);
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String name, String desc) {
+        AnnotationVisitor v = av.visitAnnotation(name, remapper.mapDesc(desc));
+        return v == null ? null : (v == av ? this
+                : new RemappingAnnotationAdapter(v, remapper));
+    }
+
+    @Override
+    public AnnotationVisitor visitArray(String name) {
+        AnnotationVisitor v = av.visitArray(name);
+        return v == null ? null : (v == av ? this
+                : new RemappingAnnotationAdapter(v, remapper));
+    }
+}

parabotv2/src/org/objectweb/asm/commons/RemappingClassAdapter.java

@@ -0,0 +1,135 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.objectweb.asm.commons;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.TypePath;
+
+/**
+ * A {@link ClassVisitor} for type remapping.
+ * 
+ * @author Eugene Kuleshov
+ */
+public class RemappingClassAdapter extends ClassVisitor {
+
+    protected final Remapper remapper;
+
+    protected String className;
+
+    public RemappingClassAdapter(final ClassVisitor cv, final Remapper remapper) {
+        this(Opcodes.ASM5, cv, remapper);
+    }
+
+    protected RemappingClassAdapter(final int api, final ClassVisitor cv,
+            final Remapper remapper) {
+        super(api, cv);
+        this.remapper = remapper;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature,
+            String superName, String[] interfaces) {
+        this.className = name;
+        super.visit(version, access, remapper.mapType(name), remapper
+                .mapSignature(signature, false), remapper.mapType(superName),
+                interfaces == null ? null : remapper.mapTypes(interfaces));
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+        AnnotationVisitor av = super.visitAnnotation(remapper.mapDesc(desc),
+                visible);
+        return av == null ? null : createRemappingAnnotationAdapter(av);
+    }
+
+    @Override
+    public AnnotationVisitor visitTypeAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath,
+                remapper.mapDesc(desc), visible);
+        return av == null ? null : createRemappingAnnotationAdapter(av);
+    }
+
+    @Override
+    public FieldVisitor visitField(int access, String name, String desc,
+            String signature, Object value) {
+        FieldVisitor fv = super.visitField(access,
+                remapper.mapFieldName(className, name, desc),
+                remapper.mapDesc(desc), remapper.mapSignature(signature, true),
+                remapper.mapValue(value));
+        return fv == null ? null : createRemappingFieldAdapter(fv);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc,
+            String signature, String[] exceptions) {
+        String newDesc = remapper.mapMethodDesc(desc);
+        MethodVisitor mv = super.visitMethod(access, remapper.mapMethodName(
+                className, name, desc), newDesc, remapper.mapSignature(
+                signature, false),
+                exceptions == null ? null : remapper.mapTypes(exceptions));
+        return mv == null ? null : createRemappingMethodAdapter(access,
+                newDesc, mv);
+    }
+
+    @Override
+    public void visitInnerClass(String name, String outerName,
+            String innerName, int access) {
+        // TODO should innerName be changed?
+        super.visitInnerClass(remapper.mapType(name), outerName == null ? null
+                : remapper.mapType(outerName), innerName, access);
+    }
+
+    @Override
+    public void visitOuterClass(String owner, String name, String desc) {
+        super.visitOuterClass(remapper.mapType(owner), name == null ? null
+                : remapper.mapMethodName(owner, name, desc),
+                desc == null ? null : remapper.mapMethodDesc(desc));
+    }
+
+    protected FieldVisitor createRemappingFieldAdapter(FieldVisitor fv) {
+        return new RemappingFieldAdapter(fv, remapper);
+    }
+
+    protected MethodVisitor createRemappingMethodAdapter(int access,
+            String newDesc, MethodVisitor mv) {
+        return new RemappingMethodAdapter(access, newDesc, mv, remapper);
+    }
+
+    protected AnnotationVisitor createRemappingAnnotationAdapter(
+            AnnotationVisitor av) {
+        return new RemappingAnnotationAdapter(av, remapper);
+    }
+}

parabotv2/src/org/objectweb/asm/commons/RemappingFieldAdapter.java

@@ -0,0 +1,71 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.objectweb.asm.commons;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.TypePath;
+
+/**
+ * A {@link FieldVisitor} adapter for type remapping.
+ * 
+ * @author Eugene Kuleshov
+ */
+public class RemappingFieldAdapter extends FieldVisitor {
+
+    private final Remapper remapper;
+
+    public RemappingFieldAdapter(final FieldVisitor fv, final Remapper remapper) {
+        this(Opcodes.ASM5, fv, remapper);
+    }
+
+    protected RemappingFieldAdapter(final int api, final FieldVisitor fv,
+            final Remapper remapper) {
+        super(api, fv);
+        this.remapper = remapper;
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+        AnnotationVisitor av = fv.visitAnnotation(remapper.mapDesc(desc),
+                visible);
+        return av == null ? null : new RemappingAnnotationAdapter(av, remapper);
+    }
+
+    @Override
+    public AnnotationVisitor visitTypeAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath,
+                remapper.mapDesc(desc), visible);
+        return av == null ? null : new RemappingAnnotationAdapter(av, remapper);
+    }
+}

parabotv2/src/org/objectweb/asm/commons/RemappingMethodAdapter.java

@@ -0,0 +1,195 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.objectweb.asm.commons;
+
+import org.objectweb.asm.AnnotationVisitor;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.TypePath;
+
+/**
+ * A {@link LocalVariablesSorter} for type mapping.
+ * 
+ * @author Eugene Kuleshov
+ */
+public class RemappingMethodAdapter extends LocalVariablesSorter {
+
+    protected final Remapper remapper;
+
+    public RemappingMethodAdapter(final int access, final String desc,
+            final MethodVisitor mv, final Remapper remapper) {
+        this(Opcodes.ASM5, access, desc, mv, remapper);
+    }
+
+    protected RemappingMethodAdapter(final int api, final int access,
+            final String desc, final MethodVisitor mv, final Remapper remapper) {
+        super(api, access, desc, mv);
+        this.remapper = remapper;
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotationDefault() {
+        AnnotationVisitor av = super.visitAnnotationDefault();
+        return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+        AnnotationVisitor av = super.visitAnnotation(remapper.mapDesc(desc),
+                visible);
+        return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
+    }
+
+    @Override
+    public AnnotationVisitor visitTypeAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath,
+                remapper.mapDesc(desc), visible);
+        return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
+    }
+
+    @Override
+    public AnnotationVisitor visitParameterAnnotation(int parameter,
+            String desc, boolean visible) {
+        AnnotationVisitor av = super.visitParameterAnnotation(parameter,
+                remapper.mapDesc(desc), visible);
+        return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
+    }
+
+    @Override
+    public void visitFrame(int type, int nLocal, Object[] local, int nStack,
+            Object[] stack) {
+        super.visitFrame(type, nLocal, remapEntries(nLocal, local), nStack,
+                remapEntries(nStack, stack));
+    }
+
+    private Object[] remapEntries(int n, Object[] entries) {
+        for (int i = 0; i < n; i++) {
+            if (entries[i] instanceof String) {
+                Object[] newEntries = new Object[n];
+                if (i > 0) {
+                    System.arraycopy(entries, 0, newEntries, 0, i);
+                }
+                do {
+                    Object t = entries[i];
+                    newEntries[i++] = t instanceof String ? remapper
+                            .mapType((String) t) : t;
+                } while (i < n);
+                return newEntries;
+            }
+        }
+        return entries;
+    }
+
+    @Override
+    public void visitFieldInsn(int opcode, String owner, String name,
+            String desc) {
+        super.visitFieldInsn(opcode, remapper.mapType(owner),
+                remapper.mapFieldName(owner, name, desc),
+                remapper.mapDesc(desc));
+    }
+
+    @Override
+    public void visitMethodInsn(int opcode, String owner, String name,
+            String desc) {
+        super.visitMethodInsn(opcode, remapper.mapType(owner),
+                remapper.mapMethodName(owner, name, desc),
+                remapper.mapMethodDesc(desc));
+    }
+
+    @Override
+    public void visitInvokeDynamicInsn(String name, String desc, Handle bsm,
+            Object... bsmArgs) {
+        for (int i = 0; i < bsmArgs.length; i++) {
+            bsmArgs[i] = remapper.mapValue(bsmArgs[i]);
+        }
+        super.visitInvokeDynamicInsn(
+                remapper.mapInvokeDynamicMethodName(name, desc),
+                remapper.mapMethodDesc(desc), (Handle) remapper.mapValue(bsm),
+                bsmArgs);
+    }
+
+    @Override
+    public void visitTypeInsn(int opcode, String type) {
+        super.visitTypeInsn(opcode, remapper.mapType(type));
+    }
+
+    @Override
+    public void visitLdcInsn(Object cst) {
+        super.visitLdcInsn(remapper.mapValue(cst));
+    }
+
+    @Override
+    public void visitMultiANewArrayInsn(String desc, int dims) {
+        super.visitMultiANewArrayInsn(remapper.mapDesc(desc), dims);
+    }
+
+    @Override
+    public AnnotationVisitor visitInsnAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        AnnotationVisitor av = super.visitInsnAnnotation(typeRef, typePath,
+                remapper.mapDesc(desc), visible);
+        return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
+    }
+
+    @Override
+    public void visitTryCatchBlock(Label start, Label end, Label handler,
+            String type) {
+        super.visitTryCatchBlock(start, end, handler, type == null ? null
+                : remapper.mapType(type));
+    }
+
+    @Override
+    public AnnotationVisitor visitTryCatchAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        AnnotationVisitor av = super.visitTryCatchAnnotation(typeRef, typePath,
+                remapper.mapDesc(desc), visible);
+        return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
+    }
+
+    @Override
+    public void visitLocalVariable(String name, String desc, String signature,
+            Label start, Label end, int index) {
+        super.visitLocalVariable(name, remapper.mapDesc(desc),
+                remapper.mapSignature(signature, true), start, end, index);
+    }
+
+    @Override
+    public AnnotationVisitor visitLocalVariableAnnotation(int typeRef,
+            TypePath typePath, Label[] start, Label[] end, int[] index,
+            String desc, boolean visible) {
+        AnnotationVisitor av = super.visitLocalVariableAnnotation(typeRef,
+                typePath, start, end, index, remapper.mapDesc(desc), visible);
+        return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
+    }
+}

parabotv2/src/org/objectweb/asm/commons/RemappingSignatureAdapter.java

@@ -0,0 +1,155 @@
+/***
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.objectweb.asm.commons;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.signature.SignatureVisitor;
+
+/**
+ * A {@link SignatureVisitor} adapter for type mapping.
+ * 
+ * @author Eugene Kuleshov
+ */
+public class RemappingSignatureAdapter extends SignatureVisitor {
+
+    private final SignatureVisitor v;
+
+    private final Remapper remapper;
+
+    private String className;
+
+    public RemappingSignatureAdapter(final SignatureVisitor v,
+            final Remapper remapper) {
+        this(Opcodes.ASM5, v, remapper);
+    }
+
+    protected RemappingSignatureAdapter(final int api,
+            final SignatureVisitor v, final Remapper remapper) {
+        super(api);
+        this.v = v;
+        this.remapper = remapper;
+    }
+
+    @Override
+    public void visitClassType(String name) {
+        className = name;
+        v.visitClassType(remapper.mapType(name));
+    }
+
+    @Override
+    public void visitInnerClassType(String name) {
+        String remappedOuter = remapper.mapType(className) + '$';
+        className = className + '$' + name;
+        String remappedName = remapper.mapType(className);
+        int index = remappedName.startsWith(remappedOuter) ? remappedOuter
+                .length() : remappedName.lastIndexOf('$') + 1;
+        v.visitInnerClassType(remappedName.substring(index));
+    }
+
+    @Override
+    public void visitFormalTypeParameter(String name) {
+        v.visitFormalTypeParameter(name);
+    }
+
+    @Override
+    public void visitTypeVariable(String name) {
+        v.visitTypeVariable(name);
+    }
+
+    @Override
+    public SignatureVisitor visitArrayType() {
+        v.visitArrayType();
+        return this;
+    }
+
+    @Override
+    public void visitBaseType(char descriptor) {
+        v.visitBaseType(descriptor);
+    }
+
+    @Override
+    public SignatureVisitor visitClassBound() {
+        v.visitClassBound();
+        return this;
+    }
+
+    @Override
+    public SignatureVisitor visitExceptionType() {
+        v.visitExceptionType();
+        return this;
+    }
+
+    @Override
+    public SignatureVisitor visitInterface() {
+        v.visitInterface();
+        return this;
+    }
+
+    @Override
+    public SignatureVisitor visitInterfaceBound() {
+        v.visitInterfaceBound();
+        return this;
+    }
+
+    @Override
+    public SignatureVisitor visitParameterType() {
+        v.visitParameterType();
+        return this;
+    }
+
+    @Override
+    public SignatureVisitor visitReturnType() {
+        v.visitReturnType();
+        return this;
+    }
+
+    @Override
+    public SignatureVisitor visitSuperclass() {
+        v.visitSuperclass();
+        return this;
+    }
+
+    @Override
+    public void visitTypeArgument() {
+        v.visitTypeArgument();
+    }
+
+    @Override
+    public SignatureVisitor visitTypeArgument(char wildcard) {
+        v.visitTypeArgument(wildcard);
+        return this;
+    }
+
+    @Override
+    public void visitEnd() {
+        v.visitEnd();
+    }
+}

parabotv2/src/org/parabot/Landing.java

@@ -1,16 +1,19 @@
 package org.parabot;
 
+import java.io.IOException;
+
+import javax.swing.JOptionPane;
+import javax.swing.UIManager;
+
+import org.matt123337.proxy.ProxySocket;
+import org.matt123337.proxy.ProxyType;
 import org.parabot.core.Core;
 import org.parabot.core.Directories;
 import org.parabot.core.forum.AccountManager;
-import org.parabot.core.spoofing.Ip;
 import org.parabot.core.ui.LoginUI;
 import org.parabot.core.ui.ServerSelector;
 import org.parabot.core.ui.utils.UILog;
 
-import javax.swing.*;
-import java.io.IOException;
-
 /**
  * Parabot v2
  *
@@ -84,9 +87,14 @@ public final class Landing {
                     username = args[++i];
                     password = args[++i];
                     break;
-                case "-proxy":
+    			case "-proxy":
-                    Ip.spoofIP(args[++i], args[++i]);
+    				String type = args[++i];
-                    break;
+    				String ip = args[++i];
+    				String port = args[++i];
+    				if (!handleProxy(type, ip, port)) {
+    					System.exit(1);
+    				}
+    				break;
                 case "-loadlocal":
                     Core.setLoadLocal(true);
                     break;
@@ -95,4 +103,25 @@ public final class Landing {
         }
     }
     
+	private static boolean handleProxy(String type, String ip, String port) {
+		ProxyType proxyType = null;
+		for (ProxyType pt : ProxyType.values()) {
+			if (pt.name().equalsIgnoreCase(type)) {
+				proxyType = pt;
+				break;
+			}
+		}
+		if (proxyType == null) {
+			System.err.println("Unknown proxy type:" + type);
+			return false;
+		}
+		try {
+			int p = Integer.parseInt(port);
+			ProxySocket.setProxy(proxyType, ip, p);
+			return true;
+		} catch (Exception e) {
+			return false;
+		}
+	}
+
 }

parabotv2/src/org/parabot/core/classpath/ClassPath.java

@@ -18,8 +18,10 @@ import java.util.jar.JarOutputStream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 
+import org.matt123337.proxy.ClassRemapper;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.RemappingClassAdapter;
 import org.objectweb.asm.tree.ClassNode;
 import org.parabot.core.Directories;
 import org.parabot.core.build.BuildPath;
@@ -186,7 +188,8 @@ public class ClassPath {
 	protected void loadClass(InputStream in) throws IOException {
 		ClassReader cr = new ClassReader(in);
 		ClassNode cn = new ClassNode();
-		cr.accept(cn, 0);
+        RemappingClassAdapter adapter = new RemappingClassAdapter(cn,new ClassRemapper());
+		cr.accept(adapter, ClassReader.EXPAND_FRAMES);
 		classes.put(cn.name, cn);
 	}
 

parabotv2/src/org/parabot/core/spoofing/Ip.java

@@ -1,14 +0,0 @@
-package org.parabot.core.spoofing;
-
-/**
- * User: Jeroen
- * Date: 27/11/13
- * Time: 16:04
- */
-public class Ip {
-    public static void spoofIP(String host, String port) {
-        System.getProperties().setProperty("socksProxySet", "true");
-        System.getProperties().setProperty("socksProxyHost", host);
-        System.getProperties().setProperty("socksProxyPort", port);
-    }
-}

parabotv2/src/org/parabot/core/ui/BotUI.java

@@ -9,6 +9,7 @@ import org.parabot.core.ui.images.Images;
 import org.parabot.core.ui.utils.SwingUtil;
 
 import javax.swing.*;
+
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
@@ -49,9 +50,12 @@ public class BotUI extends JFrame implements ActionListener {
 		JMenuBar menubar = new JMenuBar();
 
 		JMenu mnuFile = new JMenu("File");
+		JMenuItem proxy = new JMenuItem("Network");
 		JMenuItem exit = new JMenuItem("Exit");
+		proxy.addActionListener(this);
 		exit.addActionListener(this);
 
+		mnuFile.add(proxy);
 		mnuFile.add(exit);
 		menubar.add(mnuFile);
 
@@ -96,6 +100,11 @@ public class BotUI extends JFrame implements ActionListener {
 			case "Exit":
 				System.exit(0);
 				break;
+			case "Network":
+				NetworkUI proxy = NetworkUI.getInstance();
+				proxy.setLocationRelativeTo(BotUI.getInstance());
+				proxy.setVisible(true);
+				break;
 			default:
 				System.out.println("Invalid command: ");
 		}

parabotv2/src/org/parabot/core/ui/NetworkUI.java

@@ -0,0 +1,268 @@
+package org.parabot.core.ui;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.net.SocketException;
+
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextField;
+import javax.swing.ListSelectionModel;
+import javax.swing.border.EmptyBorder;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import javax.swing.text.PlainDocument;
+
+import org.matt123337.proxy.ProxySocket;
+import org.matt123337.proxy.ProxyType;
+import org.matt123337.spoofer.NetworkInterface;
+import org.parabot.core.ui.components.LogArea;
+import org.parabot.core.ui.utils.UILog;
+
+public class NetworkUI extends JFrame implements KeyListener, ActionListener,
+		DocumentListener {
+
+	private static NetworkUI instance;
+
+	private JComboBox<ProxyType> proxyType;
+	private JTextField proxyHost;
+	private IntTextField proxyPort;
+	private JButton submitButton;
+
+	JList[] macList;
+	JScrollPane[] macScrollList;
+
+	private NetworkUI() {
+		initGUI();
+	}
+
+	public static NetworkUI getInstance() {
+		return instance == null ? instance = new NetworkUI() : instance;
+	}
+
+	@Override
+	public void setVisible(boolean b) {
+		BotUI.getInstance().setEnabled(!b);
+		if (ProxySocket.getProxyAddress() != null)
+			proxyHost.setText(ProxySocket.getProxyAddress().getHostName());
+		proxyPort.setText("" + ProxySocket.getProxyPort());
+		proxyType.setSelectedItem(ProxySocket.getProxyType());
+		super.setVisible(b);
+	}
+
+	private void initGUI() {
+		proxyType = new JComboBox<ProxyType>(ProxyType.values());
+		proxyType.setSelectedItem(ProxySocket.getProxyType());
+
+		proxyHost = new JTextField();
+		proxyHost.addKeyListener(this);
+
+		proxyPort = new IntTextField(80, 5);
+		proxyPort.setColumns(5);
+		proxyPort.addKeyListener(this);
+
+		submitButton = new JButton("Submit");
+		submitButton.addActionListener(this);
+
+		byte[] mac = new byte[6];
+		try {
+			mac = NetworkInterface.getRealHardwareAddress();
+		} catch (SocketException e) {
+			e.printStackTrace();
+		}
+		macList = new JList[mac.length];
+		macScrollList = new JScrollPane[mac.length];
+		for (int i = 0; i < mac.length; i++) {
+			int value = mac[i] & 0xFF;
+			macList[i] = createMacList();
+			macList[i].setSelectedIndex(value);
+			macScrollList[i] = new JScrollPane(macList[i]);
+			macList[i].ensureIndexIsVisible(value > 0 ? value - 1 : value);
+
+		}
+		JPanel p = createPanelUI();
+		add(p);
+		setResizable(false);
+		setDefaultCloseOperation(HIDE_ON_CLOSE);
+		pack();
+		setTitle("Network Settings");
+	}
+
+	private JPanel createPanelUI() {
+		JPanel ret = new JPanel();
+		ret.setLayout(new BoxLayout(ret, BoxLayout.LINE_AXIS));
+		Box main = Box.createVerticalBox();
+
+		Box type = Box.createHorizontalBox();
+		type.add(new JLabel("Proxy Type: "));
+		type.add(proxyType);
+
+		Box host = Box.createHorizontalBox();
+		host.add(new JLabel("Proxy Host: "));
+		host.add(proxyHost);
+
+		Box port = Box.createHorizontalBox();
+		port.add(new JLabel("Proxy Port: "));
+		port.add(proxyPort);
+
+		Box macBox = Box.createHorizontalBox();
+		macBox.add(new JLabel("MAC:"));
+		for (int i = 0; i < macList.length; i++) {
+			macBox.add(new JScrollPane(macList[i]));
+			macBox.add(Box.createHorizontalStrut(5));
+		}
+
+		Box submit = Box.createHorizontalBox();
+		submit.add(submitButton);
+
+		main.add(type);
+
+		main.add(Box.createVerticalStrut(5));
+		main.add(host);
+
+		main.add(Box.createVerticalStrut(5));
+		main.add(port);
+
+		main.add(Box.createVerticalStrut(5));
+		main.add(macBox);
+
+		main.add(Box.createVerticalStrut(5));
+		main.add(submit);
+
+		ret.add(main);
+		ret.setBorder(new EmptyBorder(10, 10, 10, 10));
+		return ret;
+	}
+
+	@Override
+	public void keyPressed(KeyEvent e) {
+		Object source = e.getSource();
+		if (source == proxyPort || source == proxyHost) {
+			if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+				actionPerformed(null);
+			}
+		}
+	}
+
+	@Override
+	public void keyReleased(KeyEvent arg0) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void keyTyped(KeyEvent arg0) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void changedUpdate(DocumentEvent arg0) {
+
+	}
+
+	@Override
+	public void insertUpdate(DocumentEvent arg0) {
+		if (proxyPort.isValid()) {
+			proxyPort.setText("" + proxyPort.getValue());
+		}
+	}
+
+	@Override
+	public void removeUpdate(DocumentEvent arg0) {
+		insertUpdate(arg0);
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent arg0) {
+		byte[] mac = new byte[macList.length];
+		for (int i = 0; i < mac.length; i++)
+			mac[i] = (byte) Short.parseShort((String) macList[i].getSelectedValue(), 16);
+		NetworkInterface.mac = mac;
+
+		try {
+			if(ProxySocket.getConnectionCount() > 0) {
+				try {
+					LogArea.log("Closing Existing Connections...");
+					ProxySocket.closeConnections();
+				} catch (Exception e) {
+
+				}
+			}
+			ProxySocket.setProxy((ProxyType) proxyType.getSelectedItem(),
+					proxyHost.getText(), proxyPort.getValue());
+			UILog.log("Info", "Network settings have been set!");
+		} catch (Exception e) {
+			UILog.log("Error",
+					"Unable to set proxy info!\n\nReason:" + e.getMessage());
+			e.printStackTrace();
+		}
+		setVisible(false);
+	}
+
+	private JList createMacList() {
+		String[] hexStrings = new String[256];
+		for (int i = 0; i < 256; i++) {
+			hexStrings[i] = String.format("%02X", i);
+		}
+		JList ret = new JList<String>(hexStrings);
+		ret.setVisibleRowCount(3);
+		ret.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		return ret;
+	}
+
+	class IntTextField extends JTextField {
+		public IntTextField(int defval, int size) {
+			super("" + defval, size);
+		}
+
+		protected Document createDefaultModel() {
+			return new IntTextDocument();
+		}
+
+		public boolean isValid() {
+			try {
+				int i = Integer.parseInt(getText());
+				return i > 0 && i <= 25565;
+			} catch (Exception e) {
+				return false;
+			}
+		}
+
+		public int getValue() {
+			try {
+				return Integer.parseInt(getText());
+			} catch (NumberFormatException e) {
+				return 0;
+			}
+		}
+
+		class IntTextDocument extends PlainDocument {
+			public void insertString(int offs, String str, AttributeSet a)
+					throws BadLocationException {
+				if (str == null)
+					return;
+				String oldString = getText(0, getLength());
+				String newString = oldString.substring(0, offs) + str
+						+ oldString.substring(offs);
+				try {
+					Integer.parseInt(newString.replace("-", "") + "0");
+					super.insertString(offs, str, a);
+				} catch (NumberFormatException e) {
+				}
+			}
+		}
+	}
+}

parabotv2/src/org/parabot/core/ui/utils/UILog.java

@@ -2,6 +2,8 @@ package org.parabot.core.ui.utils;
 
 import javax.swing.JOptionPane;
 
+import org.parabot.core.ui.BotUI;
+
 /**
  * 
  * Log messages to the log user interface which is attached to the bot user interface
@@ -17,7 +19,7 @@ public class UILog {
 
 	public static void log(final String title, final String message,
 			int messageType) {
-		JOptionPane.showMessageDialog(null, message, title,
+		JOptionPane.showMessageDialog(BotUI.getInstance(), message, title,
 				messageType);
 	}