damc-dev/AgentMain.java

## AgentMain.java
/*
* JBoss, Home of Professional Open Source
* Copyright 2008-10 Red Hat and individual contributors
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*
* @authors Andrew Dinn
*/
package com.example.proj.agent;


import java.io.InputStream;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.ClassFileTransformer;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.jar.JarFile;
import java.util.ArrayList;
import java.util.List;
import java.io.File;
import java.io.IOException;
import java.io.FileInputStream;
import java.net.Socket;


/**
 * agent class supplied at JVM startup to install byteman package bytecode transformer
 */
public class AgentMain {
    public static boolean firstTime = true;
	public final static String BYTEMAN_PREFIX = "org.jboss.byteman.";

    public static void premain(String args, Instrumentation inst)
            throws Exception
    {
        // guard against the agent being loaded twice
        synchronized (AgentMain.class) {
            if (firstTime) {
                firstTime = false;
            } else {
                throw new Exception("Main : attempting to load Byteman agent more than once");
            }
        }
        boolean allowRedefine = false;
        boolean installPolicy = false;

        if (args != null) {
            // args are supplied eparated by ',' characters
            String[] argsArray = args.split(",");
            // we accept extra jar files to be added to the boot/sys classpaths
            // script files to be scanned for rules
            // listener flag which implies use of a retransformer
            for (String arg : argsArray) {
                if (arg.startsWith(BOOT_PREFIX)) {
                    bootJarPaths.add(arg.substring(BOOT_PREFIX.length(), arg.length()));
                } else if (arg.startsWith(SYS_PREFIX)) {
                    sysJarPaths.add(arg.substring(SYS_PREFIX.length(), arg.length()));
                } else if (arg.startsWith(ADDRESS_PREFIX)) {
                    hostname = arg.substring(ADDRESS_PREFIX.length(), arg.length());
                    // setting host name forces listener on
                    allowRedefine = true;
                } else if (arg.startsWith(PORT_PREFIX)) {
                    try {
                        port = Integer.valueOf(arg.substring(PORT_PREFIX.length(), arg.length()));
                        if (port <= 0) {
                            System.err.println("Invalid port specified [" + port + "]");
                            port = null;
                        } else {
                            // setting port forces listener on
                            allowRedefine = true;
                        }
                    } catch (Exception e) {
                        System.err.println("Invalid port specified [" + arg + "]. Cause: " + e);
                    }
                } else if (arg.startsWith(SCRIPT_PREFIX)) {
                    scriptPaths.add(arg.substring(SCRIPT_PREFIX.length(), arg.length()));
                } else if (arg.startsWith(RESOURCE_SCRIPT_PREFIX)) {
                    resourcescriptPaths.add(arg.substring(RESOURCE_SCRIPT_PREFIX.length(), arg.length()));
                } else if (arg.startsWith(LISTENER_PREFIX)) {
                    String value = arg.substring(LISTENER_PREFIX.length(), arg.length());
                    allowRedefine = Boolean.parseBoolean(value);
                    // clearing listener when port or host is set should be flagged
                    if (!allowRedefine && (hostname != null || port != null)) {
                        System.err.println("listener disabled with host/port set");
                    }
                } else if (arg.startsWith(REDEFINE_PREFIX)) {
                    // this is only for backwards compatibility -- it is the same as listener
                    String value = arg.substring(REDEFINE_PREFIX.length(), arg.length());
                    allowRedefine = Boolean.parseBoolean(value);
                    // clearing listener when port or host is set should be flagged
                    if (!allowRedefine && (hostname != null || port != null)) {
                        System.err.println("listener disabled with host/port set");
                    }
                } else if (arg.startsWith(PROP_PREFIX)) {
                    // this can be used to set byteman properties
                    String prop = arg.substring(PROP_PREFIX.length(), arg.length());
                    String value="";
                    if (prop.startsWith(BYTEMAN_PREFIX)) {
                        int index = prop.indexOf('=');
                        if (index > 0) {
                            // need to split off the value
                            if (index == prop.length() - 1)
                            {
                                // value is empty so just drop the =
                                prop = prop.substring(0, index);
                            } else {
                                value = prop.substring(index + 1);
                                prop = prop.substring(0, index);
                            }
                        }
                        System.out.println("Setting " + prop + "=" + value);
                        System.setProperty(prop, value);
                    } else {
                        System.err.println("Invalid property : " +  prop);
                    }
                } else if (arg.startsWith(POLICY_PREFIX)) {
                    String value = arg.substring(POLICY_PREFIX.length(), arg.length());
                    installPolicy = Boolean.parseBoolean(value);
                } else {
                    System.err.println("org.jboss.byteman.agent.Main:\n" +
                            "  illegal agent argument : " + arg + "\n" +
                            "  valid arguments are boot:<path-to-jar>, sys:<path-to-jar>, script:<path-to-script> or listener:<true-or-false>");
                }
            }
        }

        // add any boot jars to the boot class path

        for (String bootJarPath : bootJarPaths) {
            try {
                JarFile jarfile = new JarFile(new File(bootJarPath));
                inst.appendToBootstrapClassLoaderSearch(jarfile);
            } catch (IOException ioe) {
                System.err.println("org.jboss.byteman.agent.Main: unable to open boot jar file : " + bootJarPath);
                throw ioe;
            }
        }

        // add any sys jars to the system class path

        for (String sysJarPath : sysJarPaths) {
            try {
                JarFile jarfile = new JarFile(new File(sysJarPath));
                inst.appendToSystemClassLoaderSearch(jarfile);
            } catch (IOException ioe) {
                System.err.println("org.jboss.byteman.agent.Main: unable to open system jar file : " + sysJarPath);
                throw ioe;
            }
        }
        // create a socket so we can be sure it is loaded before the transformer gets cerated. otherwise
        // we seem to hit a deadlock when trying to instrument socket

        Socket dummy = new Socket();

        // look up rules in any script files

        for (String scriptPath : scriptPaths) {
            try {
                FileInputStream fis = new FileInputStream(scriptPath);
                byte[] bytes = new byte[fis.available()];
                fis.read(bytes);
                String ruleScript = new String(bytes);
                scripts.add(ruleScript);
            } catch (IOException ioe) {
                System.err.println("org.jboss.byteman.agent.Main: unable to read rule script file : " + scriptPath);
                throw ioe;
            }
        }

        // look up rules in any resource script files

        for (String scriptPath : resourcescriptPaths) {
            try {
                InputStream is = ClassLoader.getSystemResourceAsStream(scriptPath);
                if (is == null) {
                    throw new Exception("org.jboss.byteman.agent.Main: could not read rule script resource file : " + scriptPath);
                }
                byte[] bytes = new byte[is.available()];
                is.read(bytes);
                String ruleScript = new String(bytes);
                scripts.add(ruleScript);
                // merge the resource and file script paths into one list
                scriptPaths.add(scriptPath);
            } catch (IOException ioe) {
                System.err.println("org.jboss.byteman.agent.Main: error reading rule script resource file : " + scriptPath);
                throw ioe;
            }
        }

        // install an instance of Transformer to instrument the bytecode
        // n.b. this is done with boxing gloves on using explicit class loading and method invocation
        // via reflection for a GOOD reason. This class (Main) gets laoded by the System class loader.
        // If we refer to Transformer by name then it also gets loaded va the System class loader.
        // But if we want to transform a bootstrap class we need Transformer (et al) to be visible
        // from the bootstrap class loader. That will not happen until after this method has called
        // inst.appendToBootstrapClassLoaderSearch (see above) to add the byteman jar to the path.
        // Directly referring to Transformer will giveus two versions of Transformer et al. Not only
        // does that cause us class mismathc problem it also means that a new done here will not install
        // the new instance in the static field fo the oneloaded in the bootstrap loader. If instead we
        // use boxing gloves then the byteman code wil get loaded in the bootstrap loader and its constructor
        // will be called.
        //
        // Of course, if the user does not supply boot:byteman.jar as a -javaagent option then class references
        // resolve against the system loader and injection into bootstrap classes fails. But that's still ok
        // because the byteman classes are still only foudn in one place.

        boolean isRedefine = inst.isRedefineClassesSupported();

        ClassFileTransformer transformer;
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        Class transformerClazz;

        if (allowRedefine && isRedefine) {
            transformerClazz = loader.loadClass("com.example.proj.agent.AgentRetransformer");
            //transformer = new Retransformer(inst, scriptPaths, scripts, true);
            Constructor constructor = transformerClazz.getConstructor(Instrumentation.class, List.class, List.class, boolean.class);
            transformer = (ClassFileTransformer)constructor.newInstance(new Object[] { inst, scriptPaths, scripts, isRedefine});
        } else {
            transformerClazz = loader.loadClass("org.jboss.byteman.agent.Transformer");
            //transformer = new Transformer(inst, scriptPaths, scripts, isRedefine);
            Constructor constructor = transformerClazz.getConstructor(Instrumentation.class, List.class, List.class, boolean.class);
            transformer = (ClassFileTransformer)constructor.newInstance(new Object[] { inst, scriptPaths, scripts, isRedefine});
        }

        inst.addTransformer(transformer, true);

        if (allowRedefine && isRedefine) {
            Method method = transformerClazz.getMethod("addTransformListener");
            method.invoke(transformer);
        }

        if (installPolicy) {
            Method method = transformerClazz.getMethod("installPolicy");
            method.invoke(transformer);
        }

        if (isRedefine) {
            Method method = transformerClazz.getMethod("installBootScripts");
            method.invoke(transformer);
        }
    }

    public static void agentmain(String args, Instrumentation inst) throws Exception
    {
        premain(args, inst);
    }
    /**
     * prefix used to specify port argument for agent
     */
    private static final String PORT_PREFIX = "port:";

    /**
     * prefix used to specify bind address argument for agent
     */
    private static final String ADDRESS_PREFIX = "address:";

    /**
     * prefix used to specify boot jar argument for agent
     */
    private static final String BOOT_PREFIX = "boot:";

    /**
     * prefix used to specify system jar argument for agent
     */
    private static final String SYS_PREFIX = "sys:";

    /**
     * prefix used to request installation of an access-all-areas security
     * policy at install time for agent code
     */
    private static final String POLICY_PREFIX = "policy:";
    /**
     * prefix used to specify file script argument for agent
     */

    private static final String SCRIPT_PREFIX = "script:";

    /**
     * prefix used to specify resource script argument for agent
     */

    private static final String RESOURCE_SCRIPT_PREFIX = "resourcescript:";

    /**
     * prefix used to specify transformer type argument for agent
     */

    private static final String LISTENER_PREFIX = "listener:";

    /**
     * for backwards compatibiltiy
     */

    private static final String REDEFINE_PREFIX = "redefine:";

    /**
     * prefix used to specify system properties to be set before starting the agent
     */

    private static final String PROP_PREFIX = "prop:";

    /**
     * list of paths to extra bootstrap jars supplied on command line
     */
    private static List<String> bootJarPaths = new ArrayList<String>();

    /**
     * list of paths to extra system jars supplied on command line
     */
    private static List<String> sysJarPaths = new ArrayList<String>();

    /**
     * list of paths to script files supplied on command line
     */
    private static List<String> scriptPaths = new ArrayList<String>();

    /**
     * list of paths to resource script files supplied on command line
     */
    private static List<String> resourcescriptPaths = new ArrayList<String>();

    /**
     * list of scripts read from script files
     */
    private static List<String> scripts = new ArrayList<String>();

    /**
     * The hostname to bind the listener to, supplied on the command line (optional argument)
     */
    private static String hostname = null;

    /**
     * The port that the listener will listen to, supplied on the command line (optional argument)
     */
    private static Integer port = null;
}

## AgentRetransformer.java
package com.example.proj.agent;

import java.io.PrintWriter;
import java.lang.instrument.Instrumentation;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.jar.JarFile;

import org.jboss.byteman.agent.RuleScript;
import org.jboss.byteman.agent.ScriptRepository;
import org.jboss.byteman.agent.Transform;
import org.jboss.byteman.agent.Transformer;

public class AgentRetransformer extends Transformer {

    private Set<String> sysJars = new HashSet<String>();  // jar files that were loaded in the sys CL
    private Set<String> bootJars = new HashSet<String>(); // jar files that were loaded in the boot CL

    /**
     * constructor allowing this transformer to be provided with access to the JVM's instrumentation
     * implementation
     *
     * @param inst the instrumentation object used to interface to the JVM
     */
    public AgentRetransformer(Instrumentation inst, List<String> scriptPaths, List<String> scriptTexts, boolean isRedefine)
            throws Exception
    {
        super(inst, scriptPaths, scriptTexts, isRedefine);
        //addTransformListener(hostname, port);
    }

    public void installScript(List<String> scriptTexts, List<String> scriptNames, PrintWriter out) throws Exception
    {
        int length = scriptTexts.size();
        List<RuleScript> toBeAdded = new LinkedList<RuleScript>();
        List<RuleScript> toBeRemoved = new LinkedList<RuleScript>();

        for (int i = 0; i < length ; i++) {
            String scriptText = scriptTexts.get(i);
            String scriptName = scriptNames.get(i);

            List<RuleScript> ruleScripts = scriptRepository.processScripts(scriptText, scriptName);
            toBeAdded.addAll(ruleScripts);
        }

        for (RuleScript ruleScript : toBeAdded) {
            String name = ruleScript.getName();
            String className = ruleScript.getTargetClass();
            String baseName = null;
            int lastDotIdx = className.lastIndexOf('.');
            if (lastDotIdx >= 0) {
                baseName = className.substring(lastDotIdx + 1);
            }

            RuleScript previous;

            previous = scriptRepository.addScript(ruleScript);
            if (previous != null) {
                out.println("redefine rule " + name);
                toBeRemoved.add(previous);
            } else {
                out.println("install rule " + name);
            }
        }

        // ok, now that we have updated the indexes we need to find all classes which match the scripts and
        // retransform them

        // list all class names for the to be aded and to be removed scripts

        List<String> deletedClassNames = new LinkedList<String>();

        for (RuleScript ruleScript : toBeRemoved) {
            List<Transform> transforms = ruleScript.getTransformed();
            for (Transform transform : transforms) {
                String className = transform.getInternalClassName();
                if (!deletedClassNames.contains(className)) {
                    deletedClassNames.add(className);
                }
            }
        }

        // for added scripts we have to transform anything which might be a match

        ScriptRepository tmpRepository = new ScriptRepository(skipOverrideRules());
        for (RuleScript ruleScript : toBeAdded) {
            tmpRepository.addScript(ruleScript);
        }

        // now look for loaded classes whose names are in the deleted list or which match added rules

        List<Class<?>> transformed = new LinkedList<Class<?>>();

        for (Class clazz : inst.getAllLoadedClasses()) {
            if (isSkipClass(clazz)) {
                continue;
            }
            if (deletedClassNames.contains(clazz.getName())) {
                transformed.add(clazz);
            } else if (tmpRepository.matchClass(clazz)) {
                    transformed.add(clazz);
            }
        }
        // retransform all classes whose rules have changed

        if (!transformed.isEmpty()) {
            Class<?>[] transformedArray = new Class<?>[transformed.size()];
            transformed.toArray(transformedArray);
            if (Transformer.isVerbose()) {
                for (int i = 0; i < transformed.size(); i++) {
                    System.out.println("retransforming " + transformedArray[i].getName());
                }
            }
            synchronized(this) {
                try {
                    inst.retransformClasses(transformedArray);
                } catch(VerifyError ve) {
                    System.out.println("Retransformer : VerifyError during retransformation : some rules may not have been correctly injected or uninjected!");
                    ve.printStackTrace();
                    out.println("VerifyError during retransformation : some rules may not have been correctly injected or uninjected!");
                    ve.printStackTrace(out);
                }
            }
        }

        // now we can safely purge keys for all deleted scripts

        for (RuleScript ruleScript : toBeRemoved) {
            ruleScript.purge();
        }
    }

    protected void collectAffectedNames(List<RuleScript> ruleScripts, List<String> classList, List<String> interfaceList,
                                   List<String> superClassList, List<String> superInterfaceList)
    {

        for (RuleScript ruleScript : ruleScripts) {
            String targetClassName = ruleScript.getTargetClass();
            boolean isOverride = ruleScript.isOverride();
            if (ruleScript.isInterface()) {
                if (!interfaceList.contains(targetClassName)) {
                    interfaceList.add(targetClassName);
                    if (isOverride) {
                        superInterfaceList.add(targetClassName);
                    }
                }
            } else {
                if (!classList.contains(targetClassName)) {
                    classList.add(targetClassName);
                    if (isOverride) {
                        superClassList.add(targetClassName);
                    }
                }
            }
        }
    }

    protected void listScripts(PrintWriter out)  throws Exception
    {
        Iterator<RuleScript> iterator = scriptRepository.currentRules().iterator();

        if (!iterator.hasNext()) {
            out.println("no rules installed");
        } else {
            while (iterator.hasNext()) {
                RuleScript ruleScript = iterator.next();
                ruleScript.writeTo(out);
                synchronized (ruleScript) {
                    List<Transform> transformed = ruleScript.getTransformed();
                    if (transformed != null) {
                        Iterator<Transform> iter = transformed.iterator();
                        while (iter.hasNext()) {
                            Transform transform = iter.next();
                            transform.writeTo(out);
                        }
                    }
                }
            }
        }
    }

    public void addTransformListener()
    {
        ScriptReload.initialize(this);
    }

    public void removeScripts(List<String> scriptTexts, PrintWriter out) throws Exception
    {
        List<RuleScript> toBeRemoved;

        if (scriptTexts != null) {
            toBeRemoved = new LinkedList<RuleScript>();
            int length = scriptTexts.size();
            for (int i = 0; i < length ; i++) {
                String scriptText = scriptTexts.get(i);
                String[] lines = scriptText.split("\n");
                for (int j = 0; j < lines.length; j++) {
                    String line = lines[j].trim();
                    if (line.startsWith("RULE ")) {
                        String name = line.substring(5).trim();
                        RuleScript ruleScript = scriptRepository.scriptForRuleName(name);
                        if (ruleScript ==  null) {
                            out.print("ERROR failed to find loaded rule with name ");
                            out.println(name);
                        } else if (toBeRemoved.contains(ruleScript)) {
                            out.print("WARNING duplicate occurence for rule name ");
                            out.println(name);
                        } else {
                            toBeRemoved.add(ruleScript);
                        }
                    }
                }
            }
        } else {
            toBeRemoved = scriptRepository.currentRules();
        }

        if (toBeRemoved.isEmpty()) {
            out.println("ERROR No rule scripts to remove");
            return;
        }

        for (RuleScript ruleScript : toBeRemoved) {
            if (scriptRepository.removeScript(ruleScript) != ruleScript) {
                out.println("ERROR remove failed to find script " + ruleScript.getName());
            }
        }

        // ok, now that we have updated the maps and deleted the scripts
        // we need to find all classes which were transformed by
        // the scripts and retransform them


        // now look for loaded classes whose names are in the list

        List<Class<?>> transformed = new LinkedList<Class<?>>();
        List<String> deletedClassNames = new LinkedList<String>();

        for (RuleScript ruleScript : toBeRemoved) {
            List<Transform> transforms = ruleScript.getTransformed();
            if (transforms != null) {
                for (Transform transform : transforms) {
                    String className = transform.getInternalClassName();
                    if (!deletedClassNames.contains(className)) {
                        deletedClassNames.add(className);
                    }
                }
            }
        }

        for (Class clazz : inst.getAllLoadedClasses()) {
            if (isSkipClass(clazz)) {
                continue;
            }

            if (deletedClassNames.contains(clazz.getName())) {
                transformed.add(clazz);
            }
        }

        // retransform all classes affected by the change

        if (!transformed.isEmpty()) {
            Class<?>[] transformedArray = new Class<?>[transformed.size()];
            transformed.toArray(transformedArray);
            if (Transformer.isVerbose()) {
                for (int i = 0; i < transformed.size(); i++) {
                    System.out.println("retransforming " + transformedArray[i].getName());
                }
            }
            try {
                inst.retransformClasses(transformedArray);
            } catch(VerifyError ve) {
                System.out.println("Retransformer : VerifyError during retransformation : some rules may not have been correctly uninjected!");
                ve.printStackTrace();
                out.println("VerifyError during retransformation : some rules may not have been correctly uninjected!");
                ve.printStackTrace(out);
            }
        }

        // now we can safely purge keys for all the deleted scripts -- we need to do this
        // after the retransform because the latter removes the trigger code which uses
        // the rule key

        for (RuleScript ruleScript : toBeRemoved) {
            ruleScript.purge();
            out.println("uninstall RULE " + ruleScript.getName());
        }
    }

    public void appendJarFile(PrintWriter out, JarFile jarfile, boolean isBoot) throws Exception
    {
        if (isBoot) {
            inst.appendToBootstrapClassLoaderSearch(jarfile);
            bootJars.add(jarfile.getName());
            out.println("append boot jar " + jarfile.getName());
        } else {
            inst.appendToSystemClassLoaderSearch(jarfile);
            sysJars.add(jarfile.getName());
            out.println("append sys jar " + jarfile.getName());
        }
    }

    /**
     * Returns jars that this retransformer was asked to
     * {@link #appendJarFile(PrintWriter, JarFile, boolean) add} to the boot classloader.
     *
     * Note that the returned set will not include those jars that were added to the
     * instrumentor object at startup via the -javaagent command line argument.
     *
     * @return set of jar pathnames for all jars loaded in the boot classloader
     */
    public Set<String> getLoadedBootJars() {
        return new HashSet<String>(bootJars); // returns a copy
    }

    /**
     * Returns jars that this retransformer was asked to
     * {@link #appendJarFile(PrintWriter, JarFile, boolean) add} to the system classloader.
     *
     * Note that the returned set will not include those jars that were added to the
     * instrumentor object at startup via the -javaagent command line argument.
     *
     * @return set of jar pathnames for all jars loaded in the system classloader
     */
    public Set<String> getLoadedSystemJars() {
        return new HashSet<String>(sysJars); // returns a copy
    }
}

## ScriptReload.java
package com.example.proj.agent;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.jar.JarFile;

import org.jboss.byteman.agent.Transformer;

public class ScriptReload extends Thread {
	private static ScriptReload scriptReload = null;
	private AgentRetransformer retransformer;
	private static List<String> scriptTexts;
	private static List<String> scriptNames;

	ScriptReload(AgentRetransformer agentRetransformer) {
		this.retransformer = agentRetransformer;
		setDaemon(true);
	}

	public void run() {
		scriptTexts = Arrays.asList("RULE jabber\nCLASS java.lang.Thread\nMETHOD start()\nIF true\nDO traceln(\"*** start for thread: \"+ $0.getName())\nENDRULE\n");
		scriptNames = Arrays.asList("newRules.btm");

		PrintStream stdout = System.out;
		System.setOut(stdout);
		PrintWriter printWriter = new PrintWriter(stdout);

		while (true) {
			 try {
				 Thread.sleep(5000);
				 /*
				  * Get new script however you want
				  */
				 System.out.printf("Installing Scripts %s\n", scriptNames.toString());
				 retransformer.installScript(scriptTexts, scriptNames, printWriter);
			 } catch(InterruptedException e) {
				 e.printStackTrace();
			 } catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	public static synchronized boolean initialize(AgentRetransformer agentRetransformer) {

		if(scriptReload == null) {
			scriptReload = new ScriptReload(agentRetransformer);
			scriptReload.start();
		}
		return true;
	}

	private void getVersion(BufferedReader in, PrintWriter out) {
        String version = this.getClass().getPackage().getImplementationVersion();
        if (version == null) {
            version = "0";
        }
        out.println(version);
        out.println("OK");
        out.flush();
    }

    private void loadScripts(BufferedReader in, PrintWriter out) throws IOException
    {
        handleScripts(in, out, false);
    }

    private void loadJars(BufferedReader in, PrintWriter out, boolean isBoot) throws IOException
    {
        final String endMarker = (isBoot) ? "ENDBOOT" : "ENDSYS";
        String line = in.readLine().trim();
        while (line != null && !line.equals(endMarker)) {
            try {
                JarFile jarfile = new JarFile(new File(line));
                retransformer.appendJarFile(out, jarfile, isBoot);
            } catch (Exception e) {
                out.append("EXCEPTION ");
                out.append("Unable to add jar file " + line + "\n");
                out.append(e.toString());
                out.append("\n");
                e.printStackTrace(out);
            }
            line = in.readLine().trim();
        }
        if (line == null || !line.equals(endMarker)) {
            out.append("ERROR\n");
            out.append("Unexpected end of line reading " + ((isBoot) ? "boot" : "system") + " jars\n");
        }
        out.println("OK");
        out.flush();
    }

    private void deleteScripts(BufferedReader in, PrintWriter out) throws IOException
    {
        handleScripts(in, out, true);
    }

    private void handleScripts(BufferedReader in, PrintWriter out, boolean doDelete) throws IOException
    {
        List<String> scripts = new LinkedList<String>();
        List<String> scriptNames = new LinkedList<String>();

        String line = in.readLine().trim();
        String scriptName = "<unknown>";
        while (line.startsWith("SCRIPT ")) {
            StringBuffer stringBuffer = new StringBuffer();
            scriptName  = line.substring("SCRIPT ".length());
            line = in.readLine();
            while (line != null && !line.equals("ENDSCRIPT")) {
                stringBuffer.append(line);
                stringBuffer.append('\n');
                line = in.readLine();
            }

            if (line == null || !line.equals("ENDSCRIPT")) {
                out.append("ERROR\n");
                out.append("Unexpected end of line reading script " + scriptName + "\n");
                out.append("OK");
                out.flush();
                return;
            }
            String script = stringBuffer.toString();
            scripts.add(script);
            scriptNames.add(scriptName);

            line = in.readLine();
        }

        if ((doDelete && !line.equals("ENDDELETE")) ||
                (!doDelete && !line.equals("ENDLOAD"))) {
            out.append("ERROR ");
            out.append("Unexpected end of line reading script " + scriptName + "\n");
            out.println("OK");
            out.flush();
            return;
        }

        try {
            if (doDelete) {
                retransformer.removeScripts(scripts, out);
            } else {
                retransformer.installScript(scripts, scriptNames, out);
            }
        } catch (Exception e) {
            out.append("EXCEPTION ");
            out.append(e.toString());
            out.append('\n');
            e.printStackTrace(out);
        }
        out.println("OK");
        out.flush();
    }

    private void purgeScripts(BufferedReader in, PrintWriter out) throws Exception
    {
        retransformer.removeScripts(null, out);
        out.println("OK");
        out.flush();
    }

    private void listScripts(BufferedReader in, PrintWriter out) throws Exception
    {
        retransformer.listScripts(out);
        out.println("OK");
        out.flush();
    }

    private void listBootJars(BufferedReader in, PrintWriter out) throws Exception
    {
        Set<String> jars = retransformer.getLoadedBootJars();
        for (String jar : jars) {
            out.println(new File(jar).getAbsolutePath());
        }
        out.println("OK");
        out.flush();
    }

    private void listSystemJars(BufferedReader in, PrintWriter out) throws Exception
    {
        Set<String> jars = retransformer.getLoadedSystemJars();
        for (String jar : jars) {
            out.println(new File(jar).getAbsolutePath());
        }
        out.println("OK");
        out.flush();
    }

    private void listSystemProperties(BufferedReader in, PrintWriter out) throws Exception
    {
        Properties sysProps = System.getProperties();
        boolean strictMode = false;
        if (Boolean.parseBoolean(sysProps.getProperty(Transformer.SYSPROPS_STRICT_MODE, "true"))) {
            strictMode = true;
        }

        for (Map.Entry<Object, Object> entry : sysProps.entrySet()) {
            String name = entry.getKey().toString();
            if (!strictMode || name.startsWith("org.jboss.byteman.")) {
               String value = entry.getValue().toString();
               out.println(name + "=" + value.replace("\n", "\\n").replace("\r", "\\r"));
            }
        }
        out.println("OK");
        out.flush();
    }

    private void setSystemProperties(BufferedReader in, PrintWriter out) throws Exception
    {
        boolean strictMode = false;
        if (Boolean.parseBoolean(System.getProperty(Transformer.SYSPROPS_STRICT_MODE, "true"))) {
            strictMode = true;
        }

        final String endMarker = "ENDSETSYSPROPS";
        String line = in.readLine().trim();
        while (line != null && !line.equals(endMarker)) {
            try {
                String[] nameValuePair = line.split("=", 2);
                if (nameValuePair.length != 2 ) {
                    throw new Exception("missing '='");
                }
                String name = nameValuePair[0];
                String value = nameValuePair[1];
                if (strictMode && !name.startsWith("org.jboss.byteman.")) {
                    throw new Exception("strict mode is enabled, cannot set non-byteman system property");
                }
                if (name.equals(Transformer.SYSPROPS_STRICT_MODE) && !value.equals("true")) {
                    // nice try
                    throw new Exception("cannot turn off strict mode");
                }

                // everything looks good and we are allowed to set the system property now
                if (value.length() > 0) {
                	// "some.sys.prop=" means the client wants to delete the system property
                	System.setProperty(name, value);
                	out.append("Set system property [" + name + "] to value [" + value + "]\n");
                } else {
                	System.clearProperty(name);
                	out.append("Deleted system property [" + name + "]\n");
                }
                // ok, now tell the transformer a property has changed
                retransformer.updateConfiguration(name);
            } catch (Exception e) {
                out.append("EXCEPTION ");
                out.append("Unable to set system property [" + line + "]\n");
                out.append(e.toString());
                out.append("\n");
                e.printStackTrace(out);
            }
            line = in.readLine().trim();
        }
        if (line == null || !line.equals(endMarker)) {
            out.append("ERROR\n");
            out.append("Unexpected end of line reading system properties\n");
        }
        out.println("OK");
        out.flush();
    }
}
	/*
	* JBoss, Home of Professional Open Source
	* Copyright 2008-10 Red Hat and individual contributors
	* by the @authors tag. See the copyright.txt in the distribution for a
	* full listing of individual contributors.
	*
	* This is free software; you can redistribute it and/or modify it
	* under the terms of the GNU Lesser General Public License as
	* published by the Free Software Foundation; either version 2.1 of
	* the License, or (at your option) any later version.
	*
	* This software is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this software; if not, write to the Free
	* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
	*
	* @authors Andrew Dinn
	*/
	package com.example.proj.agent;


	import java.io.InputStream;
	import java.lang.instrument.Instrumentation;
	import java.lang.instrument.ClassFileTransformer;
	import java.lang.reflect.Constructor;
	import java.lang.reflect.Method;
	import java.util.jar.JarFile;
	import java.util.ArrayList;
	import java.util.List;
	import java.io.File;
	import java.io.IOException;
	import java.io.FileInputStream;
	import java.net.Socket;


	/**
	* agent class supplied at JVM startup to install byteman package bytecode transformer
	*/
	public class AgentMain {
	public static boolean firstTime = true;
	public final static String BYTEMAN_PREFIX = "org.jboss.byteman.";

	public static void premain(String args, Instrumentation inst)
	throws Exception
	{
	// guard against the agent being loaded twice
	synchronized (AgentMain.class) {
	if (firstTime) {
	firstTime = false;
	} else {
	throw new Exception("Main : attempting to load Byteman agent more than once");
	}
	}
	boolean allowRedefine = false;
	boolean installPolicy = false;

	if (args != null) {
	// args are supplied eparated by ',' characters
	String[] argsArray = args.split(",");
	// we accept extra jar files to be added to the boot/sys classpaths
	// script files to be scanned for rules
	// listener flag which implies use of a retransformer
	for (String arg : argsArray) {
	if (arg.startsWith(BOOT_PREFIX)) {
	bootJarPaths.add(arg.substring(BOOT_PREFIX.length(), arg.length()));
	} else if (arg.startsWith(SYS_PREFIX)) {
	sysJarPaths.add(arg.substring(SYS_PREFIX.length(), arg.length()));
	} else if (arg.startsWith(ADDRESS_PREFIX)) {
	hostname = arg.substring(ADDRESS_PREFIX.length(), arg.length());
	// setting host name forces listener on
	allowRedefine = true;
	} else if (arg.startsWith(PORT_PREFIX)) {
	try {
	port = Integer.valueOf(arg.substring(PORT_PREFIX.length(), arg.length()));
	if (port <= 0) {
	System.err.println("Invalid port specified [" + port + "]");
	port = null;
	} else {
	// setting port forces listener on
	allowRedefine = true;
	}
	} catch (Exception e) {
	System.err.println("Invalid port specified [" + arg + "]. Cause: " + e);
	}
	} else if (arg.startsWith(SCRIPT_PREFIX)) {
	scriptPaths.add(arg.substring(SCRIPT_PREFIX.length(), arg.length()));
	} else if (arg.startsWith(RESOURCE_SCRIPT_PREFIX)) {
	resourcescriptPaths.add(arg.substring(RESOURCE_SCRIPT_PREFIX.length(), arg.length()));
	} else if (arg.startsWith(LISTENER_PREFIX)) {
	String value = arg.substring(LISTENER_PREFIX.length(), arg.length());
	allowRedefine = Boolean.parseBoolean(value);
	// clearing listener when port or host is set should be flagged
	if (!allowRedefine && (hostname != null \|\| port != null)) {
	System.err.println("listener disabled with host/port set");
	}
	} else if (arg.startsWith(REDEFINE_PREFIX)) {
	// this is only for backwards compatibility -- it is the same as listener
	String value = arg.substring(REDEFINE_PREFIX.length(), arg.length());
	allowRedefine = Boolean.parseBoolean(value);
	// clearing listener when port or host is set should be flagged
	if (!allowRedefine && (hostname != null \|\| port != null)) {
	System.err.println("listener disabled with host/port set");
	}
	} else if (arg.startsWith(PROP_PREFIX)) {
	// this can be used to set byteman properties
	String prop = arg.substring(PROP_PREFIX.length(), arg.length());
	String value="";
	if (prop.startsWith(BYTEMAN_PREFIX)) {
	int index = prop.indexOf('=');
	if (index > 0) {
	// need to split off the value
	if (index == prop.length() - 1)
	{
	// value is empty so just drop the =
	prop = prop.substring(0, index);
	} else {
	value = prop.substring(index + 1);
	prop = prop.substring(0, index);
	}
	}
	System.out.println("Setting " + prop + "=" + value);
	System.setProperty(prop, value);
	} else {
	System.err.println("Invalid property : " + prop);
	}
	} else if (arg.startsWith(POLICY_PREFIX)) {
	String value = arg.substring(POLICY_PREFIX.length(), arg.length());
	installPolicy = Boolean.parseBoolean(value);
	} else {
	System.err.println("org.jboss.byteman.agent.Main:\n" +
	" illegal agent argument : " + arg + "\n" +
	" valid arguments are boot:<path-to-jar>, sys:<path-to-jar>, script:<path-to-script> or listener:<true-or-false>");
	}
	}
	}

	// add any boot jars to the boot class path

	for (String bootJarPath : bootJarPaths) {
	try {
	JarFile jarfile = new JarFile(new File(bootJarPath));
	inst.appendToBootstrapClassLoaderSearch(jarfile);
	} catch (IOException ioe) {
	System.err.println("org.jboss.byteman.agent.Main: unable to open boot jar file : " + bootJarPath);
	throw ioe;
	}
	}

	// add any sys jars to the system class path

	for (String sysJarPath : sysJarPaths) {
	try {
	JarFile jarfile = new JarFile(new File(sysJarPath));
	inst.appendToSystemClassLoaderSearch(jarfile);
	} catch (IOException ioe) {
	System.err.println("org.jboss.byteman.agent.Main: unable to open system jar file : " + sysJarPath);
	throw ioe;
	}
	}
	// create a socket so we can be sure it is loaded before the transformer gets cerated. otherwise
	// we seem to hit a deadlock when trying to instrument socket

	Socket dummy = new Socket();

	// look up rules in any script files

	for (String scriptPath : scriptPaths) {
	try {
	FileInputStream fis = new FileInputStream(scriptPath);
	byte[] bytes = new byte[fis.available()];
	fis.read(bytes);
	String ruleScript = new String(bytes);
	scripts.add(ruleScript);
	} catch (IOException ioe) {
	System.err.println("org.jboss.byteman.agent.Main: unable to read rule script file : " + scriptPath);
	throw ioe;
	}
	}

	// look up rules in any resource script files

	for (String scriptPath : resourcescriptPaths) {
	try {
	InputStream is = ClassLoader.getSystemResourceAsStream(scriptPath);
	if (is == null) {
	throw new Exception("org.jboss.byteman.agent.Main: could not read rule script resource file : " + scriptPath);
	}
	byte[] bytes = new byte[is.available()];
	is.read(bytes);
	String ruleScript = new String(bytes);
	scripts.add(ruleScript);
	// merge the resource and file script paths into one list
	scriptPaths.add(scriptPath);
	} catch (IOException ioe) {
	System.err.println("org.jboss.byteman.agent.Main: error reading rule script resource file : " + scriptPath);
	throw ioe;
	}
	}

	// install an instance of Transformer to instrument the bytecode
	// n.b. this is done with boxing gloves on using explicit class loading and method invocation
	// via reflection for a GOOD reason. This class (Main) gets laoded by the System class loader.
	// If we refer to Transformer by name then it also gets loaded va the System class loader.
	// But if we want to transform a bootstrap class we need Transformer (et al) to be visible
	// from the bootstrap class loader. That will not happen until after this method has called
	// inst.appendToBootstrapClassLoaderSearch (see above) to add the byteman jar to the path.
	// Directly referring to Transformer will giveus two versions of Transformer et al. Not only
	// does that cause us class mismathc problem it also means that a new done here will not install
	// the new instance in the static field fo the oneloaded in the bootstrap loader. If instead we
	// use boxing gloves then the byteman code wil get loaded in the bootstrap loader and its constructor
	// will be called.
	//
	// Of course, if the user does not supply boot:byteman.jar as a -javaagent option then class references
	// resolve against the system loader and injection into bootstrap classes fails. But that's still ok
	// because the byteman classes are still only foudn in one place.

	boolean isRedefine = inst.isRedefineClassesSupported();

	ClassFileTransformer transformer;
	ClassLoader loader = ClassLoader.getSystemClassLoader();
	Class transformerClazz;

	if (allowRedefine && isRedefine) {
	transformerClazz = loader.loadClass("com.example.proj.agent.AgentRetransformer");
	//transformer = new Retransformer(inst, scriptPaths, scripts, true);
	Constructor constructor = transformerClazz.getConstructor(Instrumentation.class, List.class, List.class, boolean.class);
	transformer = (ClassFileTransformer)constructor.newInstance(new Object[] { inst, scriptPaths, scripts, isRedefine});
	} else {
	transformerClazz = loader.loadClass("org.jboss.byteman.agent.Transformer");
	//transformer = new Transformer(inst, scriptPaths, scripts, isRedefine);
	Constructor constructor = transformerClazz.getConstructor(Instrumentation.class, List.class, List.class, boolean.class);
	transformer = (ClassFileTransformer)constructor.newInstance(new Object[] { inst, scriptPaths, scripts, isRedefine});
	}

	inst.addTransformer(transformer, true);

	if (allowRedefine && isRedefine) {
	Method method = transformerClazz.getMethod("addTransformListener");
	method.invoke(transformer);
	}

	if (installPolicy) {
	Method method = transformerClazz.getMethod("installPolicy");
	method.invoke(transformer);
	}

	if (isRedefine) {
	Method method = transformerClazz.getMethod("installBootScripts");
	method.invoke(transformer);
	}
	}

	public static void agentmain(String args, Instrumentation inst) throws Exception
	{
	premain(args, inst);
	}
	/**
	* prefix used to specify port argument for agent
	*/
	private static final String PORT_PREFIX = "port:";

	/**
	* prefix used to specify bind address argument for agent
	*/
	private static final String ADDRESS_PREFIX = "address:";

	/**
	* prefix used to specify boot jar argument for agent
	*/
	private static final String BOOT_PREFIX = "boot:";

	/**
	* prefix used to specify system jar argument for agent
	*/
	private static final String SYS_PREFIX = "sys:";

	/**
	* prefix used to request installation of an access-all-areas security
	* policy at install time for agent code
	*/
	private static final String POLICY_PREFIX = "policy:";
	/**
	* prefix used to specify file script argument for agent
	*/

	private static final String SCRIPT_PREFIX = "script:";

	/**
	* prefix used to specify resource script argument for agent
	*/

	private static final String RESOURCE_SCRIPT_PREFIX = "resourcescript:";

	/**
	* prefix used to specify transformer type argument for agent
	*/

	private static final String LISTENER_PREFIX = "listener:";

	/**
	* for backwards compatibiltiy
	*/

	private static final String REDEFINE_PREFIX = "redefine:";

	/**
	* prefix used to specify system properties to be set before starting the agent
	*/

	private static final String PROP_PREFIX = "prop:";

	/**
	* list of paths to extra bootstrap jars supplied on command line
	*/
	private static List<String> bootJarPaths = new ArrayList<String>();

	/**
	* list of paths to extra system jars supplied on command line
	*/
	private static List<String> sysJarPaths = new ArrayList<String>();

	/**
	* list of paths to script files supplied on command line
	*/
	private static List<String> scriptPaths = new ArrayList<String>();

	/**
	* list of paths to resource script files supplied on command line
	*/
	private static List<String> resourcescriptPaths = new ArrayList<String>();

	/**
	* list of scripts read from script files
	*/
	private static List<String> scripts = new ArrayList<String>();

	/**
	* The hostname to bind the listener to, supplied on the command line (optional argument)
	*/
	private static String hostname = null;

	/**
	* The port that the listener will listen to, supplied on the command line (optional argument)
	*/
	private static Integer port = null;
	}
	package com.example.proj.agent;

	import java.io.PrintWriter;
	import java.lang.instrument.Instrumentation;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Set;
	import java.util.jar.JarFile;

	import org.jboss.byteman.agent.RuleScript;
	import org.jboss.byteman.agent.ScriptRepository;
	import org.jboss.byteman.agent.Transform;
	import org.jboss.byteman.agent.Transformer;

	public class AgentRetransformer extends Transformer {

	private Set<String> sysJars = new HashSet<String>(); // jar files that were loaded in the sys CL
	private Set<String> bootJars = new HashSet<String>(); // jar files that were loaded in the boot CL

	/**
	* constructor allowing this transformer to be provided with access to the JVM's instrumentation
	* implementation
	*
	* @param inst the instrumentation object used to interface to the JVM
	*/
	public AgentRetransformer(Instrumentation inst, List<String> scriptPaths, List<String> scriptTexts, boolean isRedefine)
	throws Exception
	{
	super(inst, scriptPaths, scriptTexts, isRedefine);
	//addTransformListener(hostname, port);
	}

	public void installScript(List<String> scriptTexts, List<String> scriptNames, PrintWriter out) throws Exception
	{
	int length = scriptTexts.size();
	List<RuleScript> toBeAdded = new LinkedList<RuleScript>();
	List<RuleScript> toBeRemoved = new LinkedList<RuleScript>();

	for (int i = 0; i < length ; i++) {
	String scriptText = scriptTexts.get(i);
	String scriptName = scriptNames.get(i);

	List<RuleScript> ruleScripts = scriptRepository.processScripts(scriptText, scriptName);
	toBeAdded.addAll(ruleScripts);
	}

	for (RuleScript ruleScript : toBeAdded) {
	String name = ruleScript.getName();
	String className = ruleScript.getTargetClass();
	String baseName = null;
	int lastDotIdx = className.lastIndexOf('.');
	if (lastDotIdx >= 0) {
	baseName = className.substring(lastDotIdx + 1);
	}

	RuleScript previous;

	previous = scriptRepository.addScript(ruleScript);
	if (previous != null) {
	out.println("redefine rule " + name);
	toBeRemoved.add(previous);
	} else {
	out.println("install rule " + name);
	}
	}

	// ok, now that we have updated the indexes we need to find all classes which match the scripts and
	// retransform them

	// list all class names for the to be aded and to be removed scripts

	List<String> deletedClassNames = new LinkedList<String>();

	for (RuleScript ruleScript : toBeRemoved) {
	List<Transform> transforms = ruleScript.getTransformed();
	for (Transform transform : transforms) {
	String className = transform.getInternalClassName();
	if (!deletedClassNames.contains(className)) {
	deletedClassNames.add(className);
	}
	}
	}

	// for added scripts we have to transform anything which might be a match

	ScriptRepository tmpRepository = new ScriptRepository(skipOverrideRules());
	for (RuleScript ruleScript : toBeAdded) {
	tmpRepository.addScript(ruleScript);
	}

	// now look for loaded classes whose names are in the deleted list or which match added rules

	List<Class<?>> transformed = new LinkedList<Class<?>>();

	for (Class clazz : inst.getAllLoadedClasses()) {
	if (isSkipClass(clazz)) {
	continue;
	}
	if (deletedClassNames.contains(clazz.getName())) {
	transformed.add(clazz);
	} else if (tmpRepository.matchClass(clazz)) {
	transformed.add(clazz);
	}
	}
	// retransform all classes whose rules have changed

	if (!transformed.isEmpty()) {
	Class<?>[] transformedArray = new Class<?>[transformed.size()];
	transformed.toArray(transformedArray);
	if (Transformer.isVerbose()) {
	for (int i = 0; i < transformed.size(); i++) {
	System.out.println("retransforming " + transformedArray[i].getName());
	}
	}
	synchronized(this) {
	try {
	inst.retransformClasses(transformedArray);
	} catch(VerifyError ve) {
	System.out.println("Retransformer : VerifyError during retransformation : some rules may not have been correctly injected or uninjected!");
	ve.printStackTrace();
	out.println("VerifyError during retransformation : some rules may not have been correctly injected or uninjected!");
	ve.printStackTrace(out);
	}
	}
	}

	// now we can safely purge keys for all deleted scripts

	for (RuleScript ruleScript : toBeRemoved) {
	ruleScript.purge();
	}
	}

	protected void collectAffectedNames(List<RuleScript> ruleScripts, List<String> classList, List<String> interfaceList,
	List<String> superClassList, List<String> superInterfaceList)
	{

	for (RuleScript ruleScript : ruleScripts) {
	String targetClassName = ruleScript.getTargetClass();
	boolean isOverride = ruleScript.isOverride();
	if (ruleScript.isInterface()) {
	if (!interfaceList.contains(targetClassName)) {
	interfaceList.add(targetClassName);
	if (isOverride) {
	superInterfaceList.add(targetClassName);
	}
	}
	} else {
	if (!classList.contains(targetClassName)) {
	classList.add(targetClassName);
	if (isOverride) {
	superClassList.add(targetClassName);
	}
	}
	}
	}
	}

	protected void listScripts(PrintWriter out) throws Exception
	{
	Iterator<RuleScript> iterator = scriptRepository.currentRules().iterator();

	if (!iterator.hasNext()) {
	out.println("no rules installed");
	} else {
	while (iterator.hasNext()) {
	RuleScript ruleScript = iterator.next();
	ruleScript.writeTo(out);
	synchronized (ruleScript) {
	List<Transform> transformed = ruleScript.getTransformed();
	if (transformed != null) {
	Iterator<Transform> iter = transformed.iterator();
	while (iter.hasNext()) {
	Transform transform = iter.next();
	transform.writeTo(out);
	}
	}
	}
	}
	}
	}

	public void addTransformListener()
	{
	ScriptReload.initialize(this);
	}

	public void removeScripts(List<String> scriptTexts, PrintWriter out) throws Exception
	{
	List<RuleScript> toBeRemoved;

	if (scriptTexts != null) {
	toBeRemoved = new LinkedList<RuleScript>();
	int length = scriptTexts.size();
	for (int i = 0; i < length ; i++) {
	String scriptText = scriptTexts.get(i);
	String[] lines = scriptText.split("\n");
	for (int j = 0; j < lines.length; j++) {
	String line = lines[j].trim();
	if (line.startsWith("RULE ")) {
	String name = line.substring(5).trim();
	RuleScript ruleScript = scriptRepository.scriptForRuleName(name);
	if (ruleScript == null) {
	out.print("ERROR failed to find loaded rule with name ");
	out.println(name);
	} else if (toBeRemoved.contains(ruleScript)) {
	out.print("WARNING duplicate occurence for rule name ");
	out.println(name);
	} else {
	toBeRemoved.add(ruleScript);
	}
	}
	}
	}
	} else {
	toBeRemoved = scriptRepository.currentRules();
	}

	if (toBeRemoved.isEmpty()) {
	out.println("ERROR No rule scripts to remove");
	return;
	}

	for (RuleScript ruleScript : toBeRemoved) {
	if (scriptRepository.removeScript(ruleScript) != ruleScript) {
	out.println("ERROR remove failed to find script " + ruleScript.getName());
	}
	}

	// ok, now that we have updated the maps and deleted the scripts
	// we need to find all classes which were transformed by
	// the scripts and retransform them


	// now look for loaded classes whose names are in the list

	List<Class<?>> transformed = new LinkedList<Class<?>>();
	List<String> deletedClassNames = new LinkedList<String>();

	for (RuleScript ruleScript : toBeRemoved) {
	List<Transform> transforms = ruleScript.getTransformed();
	if (transforms != null) {
	for (Transform transform : transforms) {
	String className = transform.getInternalClassName();
	if (!deletedClassNames.contains(className)) {
	deletedClassNames.add(className);
	}
	}
	}
	}

	for (Class clazz : inst.getAllLoadedClasses()) {
	if (isSkipClass(clazz)) {
	continue;
	}

	if (deletedClassNames.contains(clazz.getName())) {
	transformed.add(clazz);
	}
	}

	// retransform all classes affected by the change

	if (!transformed.isEmpty()) {
	Class<?>[] transformedArray = new Class<?>[transformed.size()];
	transformed.toArray(transformedArray);
	if (Transformer.isVerbose()) {
	for (int i = 0; i < transformed.size(); i++) {
	System.out.println("retransforming " + transformedArray[i].getName());
	}
	}
	try {
	inst.retransformClasses(transformedArray);
	} catch(VerifyError ve) {
	System.out.println("Retransformer : VerifyError during retransformation : some rules may not have been correctly uninjected!");
	ve.printStackTrace();
	out.println("VerifyError during retransformation : some rules may not have been correctly uninjected!");
	ve.printStackTrace(out);
	}
	}

	// now we can safely purge keys for all the deleted scripts -- we need to do this
	// after the retransform because the latter removes the trigger code which uses
	// the rule key

	for (RuleScript ruleScript : toBeRemoved) {
	ruleScript.purge();
	out.println("uninstall RULE " + ruleScript.getName());
	}
	}

	public void appendJarFile(PrintWriter out, JarFile jarfile, boolean isBoot) throws Exception
	{
	if (isBoot) {
	inst.appendToBootstrapClassLoaderSearch(jarfile);
	bootJars.add(jarfile.getName());
	out.println("append boot jar " + jarfile.getName());
	} else {
	inst.appendToSystemClassLoaderSearch(jarfile);
	sysJars.add(jarfile.getName());
	out.println("append sys jar " + jarfile.getName());
	}
	}

	/**
	* Returns jars that this retransformer was asked to
	* {@link #appendJarFile(PrintWriter, JarFile, boolean) add} to the boot classloader.
	*
	* Note that the returned set will not include those jars that were added to the
	* instrumentor object at startup via the -javaagent command line argument.
	*
	* @return set of jar pathnames for all jars loaded in the boot classloader
	*/
	public Set<String> getLoadedBootJars() {
	return new HashSet<String>(bootJars); // returns a copy
	}

	/**
	* Returns jars that this retransformer was asked to
	* {@link #appendJarFile(PrintWriter, JarFile, boolean) add} to the system classloader.
	*
	* Note that the returned set will not include those jars that were added to the
	* instrumentor object at startup via the -javaagent command line argument.
	*
	* @return set of jar pathnames for all jars loaded in the system classloader
	*/
	public Set<String> getLoadedSystemJars() {
	return new HashSet<String>(sysJars); // returns a copy
	}
	}
	package com.example.proj.agent;

	import java.io.BufferedReader;
	import java.io.File;
	import java.io.IOException;
	import java.io.PrintStream;
	import java.io.PrintWriter;
	import java.util.Arrays;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.Properties;
	import java.util.Set;
	import java.util.jar.JarFile;

	import org.jboss.byteman.agent.Transformer;

	public class ScriptReload extends Thread {
	private static ScriptReload scriptReload = null;
	private AgentRetransformer retransformer;
	private static List<String> scriptTexts;
	private static List<String> scriptNames;

	ScriptReload(AgentRetransformer agentRetransformer) {
	this.retransformer = agentRetransformer;
	setDaemon(true);
	}

	public void run() {
	scriptTexts = Arrays.asList("RULE jabber\nCLASS java.lang.Thread\nMETHOD start()\nIF true\nDO traceln(\"*** start for thread: \"+ $0.getName())\nENDRULE\n");
	scriptNames = Arrays.asList("newRules.btm");

	PrintStream stdout = System.out;
	System.setOut(stdout);
	PrintWriter printWriter = new PrintWriter(stdout);

	while (true) {
	try {
	Thread.sleep(5000);
	/*
	* Get new script however you want
	*/
	System.out.printf("Installing Scripts %s\n", scriptNames.toString());
	retransformer.installScript(scriptTexts, scriptNames, printWriter);
	} catch(InterruptedException e) {
	e.printStackTrace();
	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	}
	public static synchronized boolean initialize(AgentRetransformer agentRetransformer) {

	if(scriptReload == null) {
	scriptReload = new ScriptReload(agentRetransformer);
	scriptReload.start();
	}
	return true;
	}

	private void getVersion(BufferedReader in, PrintWriter out) {
	String version = this.getClass().getPackage().getImplementationVersion();
	if (version == null) {
	version = "0";
	}
	out.println(version);
	out.println("OK");
	out.flush();
	}

	private void loadScripts(BufferedReader in, PrintWriter out) throws IOException
	{
	handleScripts(in, out, false);
	}

	private void loadJars(BufferedReader in, PrintWriter out, boolean isBoot) throws IOException
	{
	final String endMarker = (isBoot) ? "ENDBOOT" : "ENDSYS";
	String line = in.readLine().trim();
	while (line != null && !line.equals(endMarker)) {
	try {
	JarFile jarfile = new JarFile(new File(line));
	retransformer.appendJarFile(out, jarfile, isBoot);
	} catch (Exception e) {
	out.append("EXCEPTION ");
	out.append("Unable to add jar file " + line + "\n");
	out.append(e.toString());
	out.append("\n");
	e.printStackTrace(out);
	}
	line = in.readLine().trim();
	}
	if (line == null \|\| !line.equals(endMarker)) {
	out.append("ERROR\n");
	out.append("Unexpected end of line reading " + ((isBoot) ? "boot" : "system") + " jars\n");
	}
	out.println("OK");
	out.flush();
	}

	private void deleteScripts(BufferedReader in, PrintWriter out) throws IOException
	{
	handleScripts(in, out, true);
	}

	private void handleScripts(BufferedReader in, PrintWriter out, boolean doDelete) throws IOException
	{
	List<String> scripts = new LinkedList<String>();
	List<String> scriptNames = new LinkedList<String>();

	String line = in.readLine().trim();
	String scriptName = "<unknown>";
	while (line.startsWith("SCRIPT ")) {
	StringBuffer stringBuffer = new StringBuffer();
	scriptName = line.substring("SCRIPT ".length());
	line = in.readLine();
	while (line != null && !line.equals("ENDSCRIPT")) {
	stringBuffer.append(line);
	stringBuffer.append('\n');
	line = in.readLine();
	}

	if (line == null \|\| !line.equals("ENDSCRIPT")) {
	out.append("ERROR\n");
	out.append("Unexpected end of line reading script " + scriptName + "\n");
	out.append("OK");
	out.flush();
	return;
	}
	String script = stringBuffer.toString();
	scripts.add(script);
	scriptNames.add(scriptName);

	line = in.readLine();
	}

	if ((doDelete && !line.equals("ENDDELETE")) \|\|
	(!doDelete && !line.equals("ENDLOAD"))) {
	out.append("ERROR ");
	out.append("Unexpected end of line reading script " + scriptName + "\n");
	out.println("OK");
	out.flush();
	return;
	}

	try {
	if (doDelete) {
	retransformer.removeScripts(scripts, out);
	} else {
	retransformer.installScript(scripts, scriptNames, out);
	}
	} catch (Exception e) {
	out.append("EXCEPTION ");
	out.append(e.toString());
	out.append('\n');
	e.printStackTrace(out);
	}
	out.println("OK");
	out.flush();
	}

	private void purgeScripts(BufferedReader in, PrintWriter out) throws Exception
	{
	retransformer.removeScripts(null, out);
	out.println("OK");
	out.flush();
	}

	private void listScripts(BufferedReader in, PrintWriter out) throws Exception
	{
	retransformer.listScripts(out);
	out.println("OK");
	out.flush();
	}

	private void listBootJars(BufferedReader in, PrintWriter out) throws Exception
	{
	Set<String> jars = retransformer.getLoadedBootJars();
	for (String jar : jars) {
	out.println(new File(jar).getAbsolutePath());
	}
	out.println("OK");
	out.flush();
	}

	private void listSystemJars(BufferedReader in, PrintWriter out) throws Exception
	{
	Set<String> jars = retransformer.getLoadedSystemJars();
	for (String jar : jars) {
	out.println(new File(jar).getAbsolutePath());
	}
	out.println("OK");
	out.flush();
	}

	private void listSystemProperties(BufferedReader in, PrintWriter out) throws Exception
	{
	Properties sysProps = System.getProperties();
	boolean strictMode = false;
	if (Boolean.parseBoolean(sysProps.getProperty(Transformer.SYSPROPS_STRICT_MODE, "true"))) {
	strictMode = true;
	}

	for (Map.Entry<Object, Object> entry : sysProps.entrySet()) {
	String name = entry.getKey().toString();
	if (!strictMode \|\| name.startsWith("org.jboss.byteman.")) {
	String value = entry.getValue().toString();
	out.println(name + "=" + value.replace("\n", "\\n").replace("\r", "\\r"));
	}
	}
	out.println("OK");
	out.flush();
	}

	private void setSystemProperties(BufferedReader in, PrintWriter out) throws Exception
	{
	boolean strictMode = false;
	if (Boolean.parseBoolean(System.getProperty(Transformer.SYSPROPS_STRICT_MODE, "true"))) {
	strictMode = true;
	}

	final String endMarker = "ENDSETSYSPROPS";
	String line = in.readLine().trim();
	while (line != null && !line.equals(endMarker)) {
	try {
	String[] nameValuePair = line.split("=", 2);
	if (nameValuePair.length != 2 ) {
	throw new Exception("missing '='");
	}
	String name = nameValuePair[0];
	String value = nameValuePair[1];
	if (strictMode && !name.startsWith("org.jboss.byteman.")) {
	throw new Exception("strict mode is enabled, cannot set non-byteman system property");
	}
	if (name.equals(Transformer.SYSPROPS_STRICT_MODE) && !value.equals("true")) {
	// nice try
	throw new Exception("cannot turn off strict mode");
	}

	// everything looks good and we are allowed to set the system property now
	if (value.length() > 0) {
	// "some.sys.prop=" means the client wants to delete the system property
	System.setProperty(name, value);
	out.append("Set system property [" + name + "] to value [" + value + "]\n");
	} else {
	System.clearProperty(name);
	out.append("Deleted system property [" + name + "]\n");
	}
	// ok, now tell the transformer a property has changed
	retransformer.updateConfiguration(name);
	} catch (Exception e) {
	out.append("EXCEPTION ");
	out.append("Unable to set system property [" + line + "]\n");
	out.append(e.toString());
	out.append("\n");
	e.printStackTrace(out);
	}
	line = in.readLine().trim();
	}
	if (line == null \|\| !line.equals(endMarker)) {
	out.append("ERROR\n");
	out.append("Unexpected end of line reading system properties\n");
	}
	out.println("OK");
	out.flush();
	}
	}