Ooookay. IntelliJ's SVN didn't want to commit the whole thing.

git-svn-id: http://svn.igniterealtime.org/svn/repos/openfire/trunk@9792 b35dd754-fafc-0310-a699-88a17e54d16e

src/plugins/packetFilter/src/database/extra/packetfilter_oracle.sql

+CREATE TABLE pfRules(
+   id           INT          NOT NULL,
+   ruleorder    INT      ,
+   type         varchar2(255)     ,
+   tojid       varchar2(255)    ,
+   fromjid     varchar2(255)    ,
+   rulef         varchar2(255)   ,
+   disabled     INT,
+   log          INT,
+   description  varchar2(255),
+   sourcetype   varchar2(255),
+   desttype     varchar2(255),
+  CONSTRAINT pfRules_pk PRIMARY KEY (id)
+);
+
+CREATE SEQUENCE pfRules_seq
+START WITH 1
+INCREMENT BY 1
+MINVALUE 1
+NOCACHE
+NOCYCLE
+NOORDER;
+
+CREATE OR REPLACE TRIGGER pfRules_pkcreate BEFORE INSERT ON pfRules FOR EACH ROW WHEN ( NEW.id IS NULL ) BEGIN SELECT pfRules_seq.NEXTVAL INTO :NEW.id FROM DUAL; END pfRules_pkcreate;
+
+INSERT INTO jiveVersion (name,version) values ('packetfilter',1);

src/plugins/packetFilter/src/database/packetfilter_hsqldb.sql

+CREATE TABLE pfRules (
+   id           BIGINT   IDENTITY,
+   ruleorder    BIGINT      ,
+   type         varchar(255)     ,
+   tojid       varchar(255)    ,
+   fromjid     varchar(255)    ,
+   rulef         varchar(255)   ,
+   disabled     boolean,
+   log          boolean,
+   description  varchar(255),
+   sourcetype   varchar(255),
+   desttype     varchar(255),
+   CONSTRAINT  pfRules_pk PRIMARY KEY (id)
+);
+CREATE INDEX pfRules_idx ON pfRules(id);
+INSERT INTO jiveVersion(name,version) values('packetfilter',1);
\ No newline at end of file

src/plugins/packetFilter/src/database/packetfilter_mysql.sql

+CREATE TABLE pfRules (
+   id           BIGINT          NOT NULL AUTO_INCREMENT,
+   ruleorder    BIGINT      ,
+   type         varchar(255)     ,
+   tojid       varchar(255)    ,
+   fromjid     varchar(255)    ,
+   rulef         varchar(255)   ,
+   disabled     boolean,
+   log          boolean,
+   description  varchar(255),
+   sourcetype   varchar(255),
+   desttype     varchar(255),
+   PRIMARY KEY (id)
+);
+INSERT INTO jiveVersion(name,version) values('packetfilter',1);
\ No newline at end of file

src/plugins/packetFilter/src/database/packetfilter_postgresql.sql

+CREATE TABLE pfRules (
+   id           SERIAL,
+   ruleorder    BIGINT      ,
+   type         varchar(255)     ,
+   tojid       varchar(255)    ,
+   fromjid     varchar(255)    ,
+   rulef         varchar(255)   ,
+   disabled     boolean,
+   log          boolean,
+   description  varchar(255),
+   sourcetype   varchar(255),
+   desttype     varchar(255),
+   CONSTRAINT pfRules_id PRIMARY KEY(id)
+);
+
+INSERT INTO jiveVersion(name,version) values('packetfilter',1);
\ No newline at end of file

src/plugins/packetFilter/src/database/packetfilter_sqlserver.sql

+CREATE TABLE pfRules (
+   id           BIGINT IDENTITY(10,2),
+   ruleorder    BIGINT,
+   type         varchar(255),
+   tojid       varchar(255),
+   fromjid     varchar(255),
+   rulef       varchar(255),
+   disabled     bit,
+   log          bit,
+   description  varchar(255),
+   sourcetype   varchar(255),
+   desttype     varchar(255),
+   PRIMARY KEY (id)
+);
+
+INSERT INTO jiveVersion(name,version) values('packetfilter',1);
\ No newline at end of file

src/plugins/packetFilter/src/database/upgrade/1/packetfilter_hsqldb.sql

+DROP TABLE pfRules;
+CREATE TABLE pfRules (
+   id           BIGINT   IDENTITY,
+   ruleorder    BIGINT      ,
+   type         varchar(255)     ,
+   tojid       varchar(255)    ,
+   fromjid     varchar(255)    ,
+   rulef         varchar(255)   ,
+   disabled     boolean,
+   log          boolean,
+   description  varchar(255),
+   sourcetype   varchar(255),
+   desttype     varchar(255),
+   CONSTRAINT  pfRules_pk PRIMARY KEY (id)
+);
+CREATE INDEX pfRules_idx ON pfRules(id);
+UPDATE jiveVersion set version=1 where name='packetfilter';
\ No newline at end of file

src/plugins/packetFilter/src/database/upgrade/1/packetfilter_mysql.sql

+DROP TABLE pfRules;
+CREATE TABLE pfRules (
+   id           BIGINT          NOT NULL AUTO_INCREMENT,
+   ruleorder    BIGINT      ,
+   type         varchar(255)     ,
+   tojid       varchar(255)    ,
+   fromjid     varchar(255)    ,
+   rulef         varchar(255)   ,
+   disabled     boolean,
+   log          boolean,
+   description  varchar(255),
+   sourcetype   varchar(255),
+   desttype     varchar(255),
+   PRIMARY KEY (id)
+);
+UPDATE jiveVersion set version=1 where name='packetfilter';
\ No newline at end of file

src/plugins/packetFilter/src/database/upgrade/1/packetfilter_postgresql.sql

+DROP TABLE pfRules;
+CREATE TABLE pfRules (
+   id           SERIAL,
+   ruleorder    BIGINT      ,
+   type         varchar(255)     ,
+   tojid       varchar(255)    ,
+   fromjid     varchar(255)    ,
+   rulef         varchar(255)   ,
+   disabled     boolean,
+   log          boolean,
+   description  varchar(255),
+   sourcetype   varchar(255),
+   desttype     varchar(255),
+   CONSTRAINT pfRules_id PRIMARY KEY(id)
+);
+UPDATE jiveVersion set version=1 where name='packetfilter';
\ No newline at end of file

src/plugins/packetFilter/src/database/upgrade/1/packetfilter_sqlserver.sql

+DROP TABLE pfRules;
+CREATE TABLE pfRules (
+   id           BIGINT IDENTITY(10,2),
+   ruleorder    BIGINT,
+   type         varchar(255),
+   tojid       varchar(255),
+   fromjid     varchar(255),
+   rulef       varchar(255),
+   disabled     bit,
+   log          bit,
+   description  varchar(255),
+   sourcetype   varchar(255),
+   desttype     varchar(255),
+   PRIMARY KEY (id)
+);
+UPDATE jiveVersion set version=1 where name='packetfilter';
\ No newline at end of file

src/plugins/packetFilter/src/i18n/packetfilter_i18n.properties

+pf.create.rule=Create Rule
+pf.create.new.rule=Create New Rule
+pf.delete.title=Delete Rule
+pf.delete.delete=Delete Rule
+pf.global.cancel=Cancel
+login.title=Packet Filter
+pf.summary.title=Packet Filter Rules
+pf.save.edit=Edit Rule
+global.click_delete=Delete Rule
+pf.click.edit=Edit
+pf.click.up=Move Rule Up
+pf.click.down=Move Rule Down
+pf.error.sourceOther=Please specify a valid source JID or Domain
+pf.error.destOther=Please specify a valid destination JID or Domain
+
+

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/PacketFilter.java

+package org.jivesoftware.openfire.plugin;
+
+import org.jivesoftware.openfire.group.Group;
+import org.jivesoftware.openfire.group.GroupManager;
+import org.jivesoftware.openfire.group.GroupNotFoundException;
+import org.jivesoftware.openfire.plugin.rules.Rule;
+import org.jivesoftware.openfire.plugin.rules.RuleManager;
+import org.jivesoftware.util.Log;
+import org.xmpp.packet.*;
+
+public class PacketFilter {
+
+    private static PacketFilter packetFilter = new PacketFilter();
+    RuleManager ruleManager;
+
+    private PacketFilter() {
+
+    }
+
+    public static PacketFilter getInstance() {
+        return packetFilter;
+    }
+
+    public void setRuleManager(RuleManager ruleManager) {
+        this.ruleManager = ruleManager;
+    }
+
+    public Rule findMatch(Packet packet) {
+        if (packet.getTo() == null || packet.getFrom() == null) return null;
+
+        String to = packet.getTo().toBareJID();
+        String from = packet.getFrom().toBareJID();
+
+        //TODO Would it be better to keep a local copy of the rules?
+        for (Rule rule : ruleManager.getRules()) {
+
+            if (!rule.isDisabled() &&
+                    typeMatch(rule.getPackeType().toString(), packet) &&
+                    sourceDestMatch(rule.getDestType(), rule.getDestination(), to) &&
+                    sourceDestMatch(rule.getSourceType(), rule.getSource(), from)) {
+
+                return rule;
+            }
+        }
+        return null;
+    }
+
+    private boolean typeMatch(String rulePacketType, Packet packet) {
+        //Simple case. Any.
+        if (rulePacketType.equals(Rule.PacketType.Any.toString())) return true;
+
+        else if (packet instanceof Message) {
+            Message message = (Message) packet;
+            if (rulePacketType.equals(Rule.PacketType.Message.toString())) {
+                return true;
+            }
+            //Try some types.
+            else if (rulePacketType.equals(Rule.PacketType.MessageChat.toString())
+                    && message.getType().toString().equals("chat")) {
+                return true;
+            } else if (rulePacketType.equals(Rule.PacketType.MessageGroupChat.toString())
+                    && message.getType().toString().equals("groupchat")) {
+                return true;
+            }
+            return false;
+        } else if (packet instanceof Presence) {
+            if (rulePacketType.equals(Rule.PacketType.Presence.toString())) {
+                return true;
+            } else return false;
+        } else if (packet instanceof IQ) {
+            if (rulePacketType.equals(Rule.PacketType.Iq.toString())) {
+                return true;
+            } else return false;
+        }
+
+        return false;
+    }
+
+
+    private boolean sourceDestMatch(String type, String ruleToFrom, String packetToFrom) {
+        if (type.equals(Rule.SourceDestType.Any.toString())) return true;
+        if (type.equals(Rule.SourceDestType.User.toString())) {
+            if (ruleToFrom.equals(packetToFrom)) {
+                return true;
+            }
+        } else if (type.equals(Rule.SourceDestType.Group.toString())) {
+            return packetToFromGroup(ruleToFrom, packetToFrom);
+        } else if (type.equals(Rule.SourceDestType.Component.toString())) {
+            if (ruleToFrom.toLowerCase().equals(PacketFilterUtil.getComponent(packetToFrom).toLowerCase())) {
+                return true;
+            }
+        } else if (type.equals(Rule.SourceDestType.Other.toString())) {
+            if (matchUser(ruleToFrom, packetToFrom)) {
+                return true;
+            }
+
+
+        }
+        return false;
+    }
+
+    private boolean matchUser(String ruleToFrom, String packetToFrom) {
+        boolean match = false;
+        //Escape the text so I get a rule to packet match. 
+        packetToFrom = JID.unescapeNode(packetToFrom);
+        if (ruleToFrom.indexOf("*") == 0 && ruleToFrom.indexOf("@") == 1) {
+            if (PacketFilterUtil.getDomain(ruleToFrom).equals(PacketFilterUtil.getDomain(packetToFrom))) {
+                match = true;
+            }
+        } else {     
+            if (ruleToFrom.equals(packetToFrom)) {
+                match = true;
+            }
+        }
+        return match;
+    }
+
+
+    private boolean packetToFromGroup(String rulegroup, String packetToFrom) {
+        Group group = PacketFilterUtil.getGroup(rulegroup);
+        if (group == null) {
+            return false;
+        } else {
+            for (JID jid : group.getMembers()) {
+                if (jid.toBareJID().equals(packetToFrom)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/PacketFilterPlugin.java

+package org.jivesoftware.openfire.plugin;
+
+import org.jivesoftware.openfire.XMPPServer;
+import org.jivesoftware.openfire.container.Plugin;
+import org.jivesoftware.openfire.container.PluginManager;
+import org.jivesoftware.openfire.interceptor.InterceptorManager;
+import org.jivesoftware.openfire.interceptor.PacketInterceptor;
+import org.jivesoftware.openfire.interceptor.PacketRejectedException;
+import org.jivesoftware.openfire.plugin.rules.Rule;
+import org.jivesoftware.openfire.plugin.rules.RuleManager;
+import org.jivesoftware.openfire.plugin.rules.RuleManagerProxy;
+import org.jivesoftware.openfire.session.Session;
+import org.jivesoftware.util.Log;
+import org.xmpp.packet.Packet;
+
+import java.io.File;
+
+public class PacketFilterPlugin implements Plugin, PacketInterceptor {
+
+    private static PluginManager pluginManager;
+
+    public PacketFilterPlugin() {
+        XMPPServer server = XMPPServer.getInstance();
+        interceptorManager = InterceptorManager.getInstance();
+
+    }
+
+    //Packet Filter
+    private PacketFilter pf;
+
+    //Hook for intercpetorn
+    private InterceptorManager interceptorManager;
+
+
+    public void initializePlugin(PluginManager manager, File pluginDirectory) {
+        // register with interceptor manager
+        Log.info("Packet Filter loaded...");
+        interceptorManager.addInterceptor(this);
+        this.pluginManager = manager;
+        pf = PacketFilter.getInstance();
+        RuleManager ruleManager = new RuleManagerProxy();
+        pf.setRuleManager(ruleManager);
+        
+    }
+
+    public void destroyPlugin() {
+        // unregister with interceptor manager
+        interceptorManager.removeInterceptor(this);
+    }
+
+
+    public String getName() {
+        return "packetFilter";
+        
+    }
+    public static PluginManager getPluginManager() {
+        return pluginManager;
+    }
+    public void interceptPacket(Packet packet, Session session, boolean incoming, boolean processed) throws PacketRejectedException {
+
+        Rule rule = pf.findMatch(packet);
+
+        if (rule != null) {
+            rule.doAction(packet);
+        }
+    }
+}       

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/PacketFilterUtil.java

+package org.jivesoftware.openfire.plugin;
+
+import org.jivesoftware.openfire.XMPPServer;
+import org.jivesoftware.openfire.group.Group;
+import org.jivesoftware.openfire.group.GroupManager;
+import org.jivesoftware.openfire.group.GroupNotFoundException;
+import org.jivesoftware.openfire.plugin.component.ComponentList;
+import org.jivesoftware.openfire.user.UserManager;
+import org.jivesoftware.util.Log;
+import org.xmpp.packet.JID;
+
+import java.util.Collection;
+/*
+   Static util methods.
+*/
+public class PacketFilterUtil  {
+    static String serverName = XMPPServer.getInstance().getServerInfo().getName();
+
+    public static boolean isGroup(String name) {
+        try {
+            GroupManager.getInstance().getGroup(name);
+            return true;
+        } catch (GroupNotFoundException e) {
+            return false;
+        }
+    }
+
+
+    public static Group getGroup(String name) {
+        Group group = null;
+        try {
+            group = GroupManager.getInstance().getProvider().getGroup(name);
+        } catch (GroupNotFoundException e) {
+            e.printStackTrace();
+        }
+        return group;
+    }
+
+    //Faster the better. This will break if virtual hosts is ever implemented.
+    public static boolean isLocalUser(String jid) {
+        Collection<String> users = UserManager.getUserProvider().getUsernames();
+        for (String username : users) {
+            if (jid.equals(username+"@"+serverName)) {
+               return true;
+            }
+        }
+        return false;
+    }
+
+    /*
+        Method to get the component part from a jid. The packet could
+        be from the component itself so just return. 
+     */
+    public static String getComponent(String jid) {
+       if (jid.contains("@")) {
+            int atIndex = jid.indexOf("@");
+            return (jid.substring(atIndex+1,jid.length()));
+        }
+        else {
+            return jid;
+        }
+    }
+
+    public static String getDomain(String jid) {
+        return getComponent(jid);
+    }
+
+
+    /*
+        Figure out if the packet is going to a component
+     */
+   /* public static boolean isComponent(String jid) {
+        ComponentList cList = ComponentList.getInstance();
+        if (cList.getComponentName(jid) == null) {
+            return false;
+        }
+        else {
+            return true;
+        }
+
+    }
+     */
+    
+    /*
+        Make reasonably sure that the string is a valid
+        JID.
+     */
+    /*public static boolean isJID(String jid) {
+        try {
+            JID _jid = new JID(jid);
+        }
+        catch (IllegalArgumentException e) {
+            Log.error(e);
+            return false;
+        }
+
+        return true;
+    } */
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/cluster/RulesUpdatedEvent.java

+package org.jivesoftware.openfire.plugin.cluster;
+
+import org.jivesoftware.openfire.plugin.rules.RuleManager;
+import org.jivesoftware.openfire.plugin.rules.RuleManagerProxy;
+import org.jivesoftware.util.cache.ClusterTask;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+
+
+public class RulesUpdatedEvent implements ClusterTask {
+
+
+
+    public RulesUpdatedEvent() {
+
+    }
+
+    public Object getResult() {
+        return null;
+    }
+
+    public void run() {
+       RuleManager ruleManager = new RuleManagerProxy();
+       ruleManager.rulesUpdated();
+    }
+
+    public void writeExternal(ObjectOutput objectOutput) throws IOException {
+
+    }
+
+    public void readExternal(ObjectInput objectInput) throws IOException, ClassNotFoundException {
+       
+    }
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/component/ComponentList.java

+package org.jivesoftware.openfire.plugin.component;
+
+import org.dom4j.Element;
+import org.jivesoftware.openfire.IQResultListener;
+import org.jivesoftware.openfire.IQRouter;
+import org.jivesoftware.openfire.RoutingTable;
+import org.jivesoftware.openfire.XMPPServer;
+import org.jivesoftware.util.Log;
+import org.xmpp.packet.IQ;
+import org.xmpp.packet.JID;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+
+public class ComponentList implements IQResultListener {
+
+    private static ComponentList instance = new ComponentList();
+    private XMPPServer server = XMPPServer.getInstance();
+    private RoutingTable routingTable = server.getRoutingTable();
+
+    Map<String, String> componentMap = new ConcurrentHashMap<String, String>();
+
+    private ComponentList() {
+        getComponentInfo();
+    }
+
+    public Map<String, String> getComponentMap() {
+        return componentMap;
+    }
+
+    public static ComponentList getInstance() {
+        return instance;
+    }
+
+    public String getComponentName(JID jid) {
+        return componentMap.get(jid.toString());
+    }
+
+    public String getComponentName(String jid) {
+        return componentMap.get(jid);
+    }
+
+
+    public void receivedAnswer(IQ packet) {
+        if (IQ.Type.result == packet.getType()) {
+
+            Element child = packet.getChildElement();
+            if (child != null) {
+                for (Iterator it = child.elementIterator("identity"); it.hasNext();) {
+                    Element identity = (Element) it.next();
+                    String name = identity.attributeValue("name");
+                    componentMap.put(packet.getFrom().toString(), name);
+                }
+            }
+        }
+    }
+
+    public void answerTimeout(String packetId) {
+       Log.warn("An answer to a previously sent IQ stanza was never received. Packet id: " + packetId);
+    }
+
+
+    public Collection<String> getComponentDomains() {
+        return routingTable.getComponentsDomains();
+    }
+
+    public Collection<String> getComponentNames() {
+        return componentMap.values();
+    }
+
+    private void getComponentInfo() {
+        IQRouter iqRouter;
+        Collection<String> components = routingTable.getComponentsDomains();
+        iqRouter = server.getIQRouter();
+        for (String componentDomain : components) {
+            IQ iq = new IQ(IQ.Type.get);
+            iq.setFrom(server.getServerInfo().getName());
+            iq.setTo(componentDomain);
+            iq.setChildElement("query", "http://jabber.org/protocol/disco#info");
+            iqRouter.addIQResultListener(iq.getID(), this);
+            iqRouter.route(iq);
+        }
+    }
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/AbstractRule.java

+package org.jivesoftware.openfire.plugin.rules;
+
+import org.jivesoftware.openfire.interceptor.PacketRejectedException;
+import org.xmpp.packet.Packet;
+
+import java.util.List;
+
+
+public abstract class AbstractRule implements Rule {
+
+    private Action packetAction;
+    private PacketType packetType;
+    private Boolean disabled;
+    private String source;
+    private String destination;
+    private Boolean log;
+    private String description;
+    private String ruleId;
+    private String displayName;
+    private String sourceType;
+    private String destType;
+
+
+    public String getDestType() {
+        return destType;
+    }
+
+    public void setDestType(String destType) {
+        this.destType = destType;
+    }
+
+    public String getSourceType() {
+        return sourceType;
+    }
+
+    public void setSourceType(String sourceType) {
+        this.sourceType = sourceType;
+    }
+
+    public int getOrder() {
+        return order;
+    }
+
+    public void setOrder(int order) {
+        this.order = order;
+    }
+
+    private int order;
+
+
+    public void setDisplayName(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    public String getRuleId() {
+        return ruleId;
+    }
+
+    public void setRuleId(String ruleId) {
+        this.ruleId = ruleId;
+    }
+
+    public String getRuleType() {
+        return this.getClass().getName();
+    }
+
+
+    public Action getPacketAction() {
+        return packetAction;
+    }
+
+    public void setPacketAction(Action packetAction) {
+        this.packetAction = packetAction;
+    }
+
+    public PacketType getPackeType() {
+        return packetType;
+    }
+
+    public void setPacketType(PacketType packetType) {
+        this.packetType = packetType;
+    }
+
+    public Boolean isDisabled() {
+        return disabled;
+    }
+
+    public void isDisabled(Boolean disabled) {
+        this.disabled = disabled;
+    }
+
+    public String getSource() {
+        return source;
+    }
+
+    public void setSource(String source) {
+        this.source = source;
+    }
+
+    public String getDestination() {
+        return destination;
+    }
+
+    public void setDestination(String destination) {
+        this.destination = destination;
+    }
+
+    public Boolean doLog() {
+        return log;
+    }
+
+    public void doLog(Boolean log) {
+        this.log = log;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public Packet doAction(Packet packet) throws PacketRejectedException {
+        return null;
+    }
+
+    public boolean sourceMustMatch() {
+        return true;
+    }
+
+    public boolean destMustMatch() {
+        return true;
+    }
+
+
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        if (packetAction != null)
+        sb.append("Type : "+packetAction.toString()+'\n');
+        sb.append("Order : "+getOrder()+'\n');
+        sb.append("Diplay Name : "+getDisplayName()+'\n');
+        sb.append("Packet Type : "+packetType+'\n');
+        sb.append("ID : "+ruleId+'\n');
+        sb.append("Soruce Type : "+sourceType+'\n');
+        sb.append("Source : "+source+'\n');
+        sb.append("Dest Type : "+destType+'\n');
+        sb.append("Destination : "+destination+'\n');
+        sb.append("Loging : "+log+'\n');
+        sb.append("Disabled : "+disabled+'\n');
+        return sb.toString();
+    }
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/Drop.java

+package org.jivesoftware.openfire.plugin.rules;
+
+import org.xmpp.packet.Packet;
+import org.jivesoftware.util.Log;
+import org.jivesoftware.openfire.interceptor.PacketRejectedException;
+
+
+public class Drop extends AbstractRule implements Rule {
+
+    public String getDisplayName() {
+        return "Drop";
+    }
+
+    public Packet doAction(Packet packet) throws PacketRejectedException {
+        if (doLog()) {
+            Log.info("Dropping from "+packet.getFrom()+" to "+packet.getTo());
+        }
+        throw new PacketRejectedException();
+    }
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/Pass.java

+package org.jivesoftware.openfire.plugin.rules;
+
+import org.xmpp.packet.Packet;
+import org.jivesoftware.openfire.interceptor.PacketRejectedException;
+import org.jivesoftware.util.Log;
+
+public class Pass extends AbstractRule implements Rule {
+
+    public String getDisplayName() {
+        return "Pass";
+    }
+
+    public Packet doAction(Packet packet) throws PacketRejectedException {
+        if (doLog()) {
+            Log.info("Passing from "+packet.getFrom()+" to "+packet.getTo());
+        }
+        return null;
+    }
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/Redirect.java

+package org.jivesoftware.openfire.plugin.rules;
+
+import org.jivesoftware.openfire.SessionManager;
+import org.jivesoftware.openfire.XMPPServer;
+import org.jivesoftware.openfire.group.Group;
+import org.jivesoftware.openfire.interceptor.PacketRejectedException;
+import org.jivesoftware.openfire.plugin.PacketFilterUtil;
+import org.jivesoftware.openfire.session.ClientSession;
+import org.jivesoftware.util.Log;
+import org.xmpp.packet.JID;
+import org.xmpp.packet.Message;
+import org.xmpp.packet.Packet;
+
+import java.util.Collection;
+
+public class Redirect extends AbstractRule implements Rule {
+     public String getDisplayName() {
+        return "Redirect";                                                                   
+    }
+
+    public Packet doAction(Packet packet) throws PacketRejectedException {
+       Message newPacket = null;
+        
+       if (packet instanceof Message) {
+
+        if (getDestType().equals(Rule.SourceDestType.Group.toString())) {
+            Group sendGroup = PacketFilterUtil.getGroup(getDestination());
+            ClientSession clientSession;
+            for (JID jid : sendGroup.getMembers()) {
+                newPacket = (Message) packet.createCopy();
+                newPacket.setTo(jid);
+                sendPacket(newPacket);
+            }
+        }
+
+        else {
+
+                JID jid = new JID(getDestination());
+                newPacket = (Message) packet.createCopy();
+                newPacket.setFrom("test@machintosh.local");
+                newPacket.setTo(jid);
+
+                sendPacket(newPacket);
+        }
+
+        if (doLog())  {
+            Log.info("Redirecting from "+packet.getFrom()+" to "+packet.getTo());
+        }
+       }
+
+       throw new PacketRejectedException();
+        
+    }
+
+    public boolean destMustMatch() {
+        return false;
+    }
+
+    private static void sendPacket(Packet packet) {
+        SessionManager sessionManager = XMPPServer.getInstance().getSessionManager();
+        ClientSession clientSession;
+
+        clientSession = sessionManager.getSession(packet.getTo());
+
+
+        Log.info("Sending to "+packet.getTo());
+        if (clientSession != null) {
+            Log.info("***** Session Not Null ******");
+            clientSession.process(packet);
+        }
+    }
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/Reject.java

+package org.jivesoftware.openfire.plugin.rules;
+
+import org.jivesoftware.openfire.SessionManager;
+import org.jivesoftware.openfire.interceptor.PacketRejectedException;
+import org.jivesoftware.openfire.session.ClientSession;
+import org.jivesoftware.util.JiveGlobals;
+import org.jivesoftware.util.Log;
+import org.xmpp.packet.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Reject extends AbstractRule implements Rule {
+
+    public String getDisplayName() {
+        return "Reject";
+    }
+
+    public Packet doAction(Packet packet) throws PacketRejectedException {
+        SessionManager sessionManager = SessionManager.getInstance();
+        ClientSession clientSession = sessionManager.getSession(packet.getFrom());
+        Packet rejectPacket;
+        String pfFrom = JiveGlobals.getProperty("pf.From", "packetfilter");
+
+
+        if (packet instanceof Message) {
+            Message in = (Message) packet.createCopy();
+            if (clientSession != null && in.getBody() != null) {
+
+                in.setFrom(new JID(pfFrom));
+                String rejectMessage = JiveGlobals.getProperty("pf.rejectMessage", "Your message was rejected by the packet filter");
+                in.setBody(rejectMessage);
+                in.setType(Message.Type.error);
+                in.setTo(packet.getFrom());
+                String rejectSubject = JiveGlobals.getProperty("pf.rejectSubject", "Rejected");
+                in.setSubject(rejectSubject);
+                clientSession.process(in);
+
+            }
+
+        } else if (packet instanceof Presence) {
+            rejectPacket = new Presence();
+            rejectPacket.setTo(packet.getFrom());
+            rejectPacket.setError(PacketError.Condition.forbidden);
+
+        } else if (packet instanceof IQ) {
+            rejectPacket = new IQ();
+            rejectPacket.setTo(packet.getFrom());
+            rejectPacket.setError(PacketError.Condition.forbidden);
+
+        }
+        if (doLog()) {
+            Log.info("Rejecting packet from " + packet.getFrom() + " to " + packet.getTo());
+        }
+        throw new PacketRejectedException();
+    }
+
+    
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/Rule.java

+package org.jivesoftware.openfire.plugin.rules;
+
+import org.jivesoftware.openfire.interceptor.PacketRejectedException;
+import org.xmpp.packet.Packet;
+
+import java.util.List;
+
+public interface Rule {
+    enum Action {
+        Pass,
+        Drop,
+        Reject
+    }
+
+    ;
+
+    enum PacketType {
+        Message("Message"),
+        MessageChat("MUC Private Message"),
+        MessageGroupChat("MUC"),
+        Presence("Presence"),
+        Iq("Iq"),
+        Any("Any");
+
+        private String display;
+
+        PacketType(String display) {
+            this.display = display;
+        }
+
+        public String getDisplayName() {
+            return display;
+        }
+    }
+
+    ;
+
+    enum SourceDestType {
+        Any,
+        User,
+        Group,
+        Component,
+        Other
+    }
+
+    ;
+
+
+    public Action getPacketAction();
+
+    public void setPacketAction(Action action);
+
+    public PacketType getPackeType();
+
+    public void setPacketType(PacketType packetType);
+
+    public Boolean isDisabled();
+
+    public void isDisabled(Boolean disabled);
+
+    public String getSource();
+
+    public void setSource(String source);
+
+    public String getDestination();
+
+    public void setDestination(String destination);
+
+    public Boolean doLog();
+
+    public void doLog(Boolean log);
+
+    public String getDescription();
+
+    public void setDescription(String description);
+
+    public String getRuleId();
+
+    public void setRuleId(String id);
+
+    public int getOrder();
+
+    public void setOrder(int order);
+
+    public String getRuleType();
+
+    public String getDisplayName();
+
+    public void setDisplayName(String displayName);
+
+    public String getSourceType();
+
+    public void setSourceType(String sourceType);
+
+    public String getDestType();
+
+    public void setDestType(String destType);
+    
+
+    public Packet doAction(Packet packet) throws PacketRejectedException;
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/RuleManager.java

+package org.jivesoftware.openfire.plugin.rules;
+
+import java.util.List;
+
+public interface RuleManager {
+
+    public Rule getRuleById(int id);
+
+    public List<Rule> getRules();
+
+    public void addRule(Rule rule, Integer order);
+
+    public void addRule(Rule rule);
+
+    public void deleteRule(String ruleId);
+
+    public void moveOne(int srcId, int destId);
+    public int getLastOrder();
+
+    public void moveRuleOrder(int ruleId,int orderId) ;
+
+    public void updateRule(Rule rule);
+
+    public void rulesUpdated();
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/RuleManagerProxy.java

+package org.jivesoftware.openfire.plugin.rules;
+
+
+import java.util.List;
+
+public class RuleManagerProxy implements RuleManager {
+
+    private DbRuleManager dbRuleManager = DbRuleManager.getInstance();
+    private List<Rule> rules = null;
+
+    public RuleManagerProxy() {
+       // rules = dbRuleManager.getRules();
+    }
+
+    public Rule getRuleById(int id) {
+        //Pull it from the db
+        return dbRuleManager.getRuleById(id);
+    }
+
+    public List<Rule> getRules() {
+        return  dbRuleManager.getRules();
+    }
+
+    public void addRule(Rule rule, Integer order) {
+       /*if (order != null && order.intValue() > 0) {
+            DbRuleManager.getInstance().addRule(rule,order);
+        }
+        rules.add(order.intValue(),rule);
+         */
+         
+    }
+
+    public void addRule(Rule rule) {
+        dbRuleManager.addRule(rule);
+        //rulesUpdated();
+    }
+
+    public void deleteRule(String ruleId) {
+        //Remove rule from storage (db)
+        dbRuleManager.deleteRule(ruleId);
+
+        //Recreate array.
+        /*for (Rule rule : rules) {
+            if (rule == null) break;
+            if (rule.getRuleId().equals(ruleId)) {
+                rules.remove(rule);
+            }
+        } */
+    }
+
+    public void moveOne(int srcId, int destId) {
+        Rule srcRule = dbRuleManager.getRuleById(srcId);
+        Rule destRule = dbRuleManager.getRuleById(destId);
+
+        dbRuleManager.moveOne(srcRule,destRule);
+        //rulesUpdated();
+
+    }
+
+    public int getLastOrder() {
+        //Get the last rule in the "Cache" and return it's order
+        //if (rules.size() == 0) return 0;
+       // return rules.get(rules.size()-1).getOrder();
+        return dbRuleManager.getLastOrderId();
+    }
+
+    public void moveRuleOrder(int ruleId,int orderId) {
+        dbRuleManager.moveRuleOrder(ruleId,orderId);
+       // rulesUpdated();
+    }
+
+    public void updateRule(Rule rule) {
+       dbRuleManager.updateRule(rule);
+       //rulesUpdated();
+    }
+
+    public void rulesUpdated() {
+        reloadRules();
+    }
+
+    private void reloadRules() {
+        dbRuleManager.clear();
+    }
+}

src/plugins/packetFilter/src/java/org/jivesoftware/openfire/plugin/rules/RuleOption.java

+package org.jivesoftware.openfire.plugin.rules;
+
+
+public class RuleOption {
+
+    private String name;
+    private String type;
+    private boolean required;
+    private String value;
+
+
+    public RuleOption() {}
+
+    public RuleOption(String name, String type, boolean required, String value) {
+        this.name = name;
+        this.value = value;
+        this.type = type;
+        this.required = required;
+    }
+
+    
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Object getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public boolean isRequired() {
+        return required;
+    }
+
+    public void setRequired(boolean required) {
+        this.required = required;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+}

src/plugins/packetFilter/src/test/MockRuleManager.java

+import org.jivesoftware.openfire.plugin.rules.RuleManager;
+import org.jivesoftware.openfire.plugin.rules.Rule;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class MockRuleManager implements RuleManager {
+
+    List<Rule> rules = new ArrayList<Rule>();
+    public Rule getRuleById(int id) {
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public List<Rule> getRules() {
+        return rules;
+    }
+
+    public void addRule(Rule rule, Integer order) {
+        rules.add(order,rule);
+    }
+
+    public void addRule(Rule rule) {
+        rules.add(rule);
+    }
+
+    public void deleteRule(String ruleId) {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public void moveOne(int srcId, int destId) {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public int getLastOrder() {
+        return 0;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public void moveRuleOrder(int ruleId, int orderId) {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public void updateRule(Rule rule) {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public void rulesUpdated() {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+
+}

src/plugins/packetFilter/src/test/PacketFilterTest.java

+import org.jivesoftware.openfire.group.Group;
+import org.jivesoftware.openfire.interceptor.PacketRejectedException;
+import org.jivesoftware.openfire.plugin.PacketFilter;
+import org.jivesoftware.openfire.plugin.rules.Drop;
+import org.jivesoftware.openfire.plugin.rules.Rule;
+import org.jivesoftware.openfire.plugin.rules.RuleManager;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.xmpp.packet.IQ;
+import org.xmpp.packet.Message;
+import org.xmpp.packet.Presence;
+
+public class PacketFilterTest {
+
+    private PacketFilter packetFilter;
+    private RuleManager rmp;
+
+    @BeforeClass
+    public void setup() {
+        //Create a packetFilter
+        packetFilter = PacketFilter.getInstance();
+        rmp = new MockRuleManager();
+        packetFilter.setRuleManager(rmp);
+
+    }
+
+
+    @Test(groups = {"default"}, expectedExceptions = PacketRejectedException.class)
+    public void testDropMessage() throws PacketRejectedException {
+//Create some rules
+        Rule drop = new Drop();
+        drop.setSource("bart@localhost");
+        drop.setSourceType("User");
+
+        drop.setDestination("Any");
+        drop.setDestType("Any");
+
+        drop.isDisabled(false);
+        drop.setPacketType(Rule.PacketType.Message);
+        drop.doLog(false);
+
+        rmp.addRule(drop);
+        Message message = new Message();
+        message.setFrom("bart@localhost");
+        message.setTo("lisa@localhost");
+        Rule rule = packetFilter.findMatch(message);
+        assert (rule != null);
+        rule.doAction(message);
+    }
+
+    @Test(groups = {"default"}, expectedExceptions = PacketRejectedException.class)
+    public void testDropIQ() throws PacketRejectedException {
+//Create some rules
+        Rule drop = new Drop();
+        drop.setSource("bart@localhost");
+        drop.setSourceType("User");
+
+        drop.setDestination("Any");
+        drop.setDestType("Any");
+
+        drop.isDisabled(false);
+        drop.setPacketType(Rule.PacketType.Iq);
+        drop.doLog(false);
+        rmp.addRule(drop);
+        IQ iq = new IQ();
+        iq.setFrom("bart@localhost");
+        iq.setTo("lisa@localhost");
+        Rule rule = packetFilter.findMatch(iq);
+        assert (rule != null);
+        rule.doAction(iq);
+    }
+
+    @Test(groups = {"default"}, expectedExceptions = PacketRejectedException.class)
+    public void testDropPresence() throws PacketRejectedException {
+//Create some rules
+        Rule drop = new Drop();
+        drop.setSource("bart@localhost");
+        drop.setSourceType("User");
+        drop.setDestination("Any");
+        drop.setDestType("Any");
+        drop.isDisabled(false);
+        drop.setPacketType(Rule.PacketType.Presence);
+        drop.doLog(false);
+        rmp.addRule(drop);
+        Presence presence = new Presence();
+        presence.setFrom("bart@localhost");
+        presence.setTo("lisa@localhost");
+        Rule rule = packetFilter.findMatch(presence);
+        assert (rule != null);
+        rule.doAction(presence);
+    }
+
+    @Test(groups = {"default"}, expectedExceptions = PacketRejectedException.class)
+    public void testDropAnyType() throws PacketRejectedException {
+//Create some rules
+        Rule drop = new Drop();
+        drop.setSource("bart@localhost");
+        drop.setSourceType(Rule.SourceDestType.User.toString());
+        drop.setDestination("Any");
+        drop.setDestType(Rule.SourceDestType.Any.toString());
+        drop.isDisabled(false);
+        drop.setPacketType(Rule.PacketType.Any);
+        drop.doLog(false);
+        rmp.addRule(drop);
+        Presence presence = new Presence();
+        presence.setFrom("bart@localhost");
+        presence.setTo("lisa@localhost");
+        Rule rule = packetFilter.findMatch(presence);
+        assert (rule != null);
+        rule.doAction(presence);
+    }
+
+    /*@Test(groups = {"default"}, expectedExceptions = PacketRejectedException.class)
+    public void testGroupDrop() throws PacketRejectedException {
+        Group 
+    } */
+
+
+}

src/plugins/packetFilter/src/test/Test.java

+import org.jivesoftware.openfire.plugin.PacketFilterUtil;
+import org.xmpp.packet.JID;
+
+public class Test {
+
+    public static void main(String... args) {
+
+        String jid = JID.escapeNode("test@domain1.com@otherdomain.com");
+        String allDomain  = "*@domain1.com@otherdomain.com";
+        System.out.println(matchUser(allDomain,jid));
+
+    }
+
+    public static String getComponent(String jid) {
+        if (jid.contains("@")) {
+            int atIndex = jid.indexOf("@");
+            return (jid.substring(atIndex,jid.length()));
+        }
+        else {
+            return jid;
+        }
+    }
+
+    public static String getDomain(String jid) {
+        return getComponent(jid);
+    }
+
+     public static boolean isJID(String jid) {
+        if (jid != null &&
+                (jid.split("@").length == 1) &&
+                jid.length() < 255 &&
+                jid.trim().length() > 0) {
+            return true;
+        } else return false;
+    }
+
+    private static boolean matchUser(String ruleToFrom, String packetToFrom) {
+        boolean match = false;
+        packetToFrom = JID.unescapeNode(packetToFrom);
+        if (ruleToFrom.indexOf("*") == 0 && ruleToFrom.indexOf("@") == 1) {
+            System.out.println(getDomain(ruleToFrom));
+            System.out.println(getDomain(packetToFrom));
+            if (getDomain(ruleToFrom).equals(getDomain(packetToFrom))) {
+                match = true;
+            }
+        }
+        else {
+            if (ruleToFrom.equals(packetToFrom)) {
+                match = true;
+            }
+        }
+        return match;
+    }
+}

src/plugins/packetFilter/src/web/delete-rule.jsp

+
+<%@ page import="org.jivesoftware.util.*"%>
+<%@ page import="org.jivesoftware.openfire.plugin.rules.RuleManagerProxy" %>
+<%@ page import="org.jivesoftware.openfire.plugin.rules.Rule" %>
+<%@ page import="org.jivesoftware.openfire.plugin.rules.RuleManager" %>
+
+<%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix="c" %>
+<%@ taglib uri="http://java.sun.com/jstl/fmt_rt" prefix="fmt" %>
+
+<jsp:useBean id="webManager" class="org.jivesoftware.util.WebManager" />
+<% webManager.init(request, response, session, application, out ); %>
+
+<% // Get parameters //
+    boolean cancel = request.getParameter("cancel") != null;
+    boolean delete = request.getParameter("delete") != null;
+    String ruleId = ParamUtils.getParameter(request, "ruleId");
+
+    RuleManager rm = new RuleManagerProxy();
+    Rule rule = rm.getRuleById(new Integer(ruleId));
+
+    // Handle a cancel
+    if (cancel) {
+        response.sendRedirect("pf-main.jsp");
+        return;
+    }
+    if (delete) {
+        rm.deleteRule(ruleId);
+        response.sendRedirect("pf-main.jsp");
+    }
+%>
+
+<html>
+    <head>
+        <title><fmt:message key="pf.delete.title"/></title>
+        <meta name="pageID" content="packetFilter"/>
+    </head>
+    <body>
+
+    You have choosen to delete the rule form <%=rule.getSource()%> to <%=rule.getDestination()%>. Are you sure?
+
+    <br>
+    <br>
+
+<form action="delete-rule.jsp">
+<input type="hidden" name="ruleId" value="<%=ruleId%>">
+<input type="submit" name="delete" value="<fmt:message key="pf.delete.delete" />">
+<input type="submit" name="cancel" value="<fmt:message key="pf.global.cancel" />">
+</form>
+</body>
+</html>

src/plugins/packetFilter/src/web/pf-main.jsp

+<%@ page import="org.jivesoftware.openfire.component.InternalComponentManager,
+                 org.jivesoftware.openfire.plugin.component.ComponentList,
+                 org.jivesoftware.openfire.plugin.rules.Rule,
+                 org.jivesoftware.openfire.plugin.rules.RuleManager"
+        %>
+<%@ page import="org.jivesoftware.openfire.plugin.rules.RuleManagerProxy" %>
+<%@ page import="org.xmpp.packet.JID" %>
+<%@ page import="java.util.List" %>
+
+<%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix="c" %>
+<%@ taglib uri="http://java.sun.com/jstl/fmt_rt" prefix="fmt" %>
+
+<jsp:useBean id="webManager" class="org.jivesoftware.util.WebManager"/>
+<%
+    webManager.init(request, response, session, application, out);
+    RuleManager rm = new RuleManagerProxy();
+    ComponentList componentManager = ComponentList.getInstance();
+    int i = 0;
+
+    boolean moveOne = request.getParameter("moveOne") != null;
+
+    if (moveOne) {
+        int destId = new Integer(request.getParameter("moveOne")).intValue();
+        int srcId = new Integer(request.getParameter("ruleId")).intValue();
+        rm.moveOne(srcId, destId);
+        response.sendRedirect("pf-main.jsp");
+    }
+
+    List<Rule> rules = rm.getRules();
+    int lastOrder = rm.getLastOrder();
+%>
+
+<html>
+<head>
+    <style type="text/css">
+        <!--
+        @import url( "style/packetfilter.css" );
+        -->
+    </style>
+    <title>
+        <fmt:message key="pf.summary.title"/>
+    </title>
+    <meta name="pageID" content="packetFilter"/>
+    <meta name="helpPage" content=""/>
+    <script language="JavaScript" type="text/javascript" src="scripts/packetfilter.js"></script>
+    
+
+</head>
+<body>
+
+
+<div class="jive-table">
+    <table cellpadding="0" cellspacing="0" border="0" width="100%">
+        <thead>
+            <tr>
+                <th nowrap>Rule Type</th>
+                <th nowrap>From</th>
+                <th nowrap>To</th>
+                <th nowrap>Packet Type</th>
+                <th nowrap>Log</th>
+                <th>&nbsp</th>
+            </tr>
+        </thead>
+
+        <tbody>
+            <%
+                for (Rule rule : rules) {
+
+
+            %>
+
+            <tr class="jive-<%= (((i%2)==0) ? "even" : "odd") %>">
+
+                <% if (rule.isDisabled()) { %>
+                       <td><strike><%=rule.getDisplayName()%></strike></td>
+                    <%} else {%>
+                        <td><%=rule.getDisplayName()%></td>
+                    <%}%>
+                <% if (rule.isDisabled()) { %>
+                      <td><strike><%=rule.getSource()%></strike></td>
+                    <%} else if (rule.getSourceType().equals(Rule.SourceDestType.Component.toString())
+                            && componentManager.getComponentName(new JID(rule.getSource()))!= null) { %>
+                        <td><%=componentManager.getComponentName(new JID(rule.getSource()))%></td>
+                    <% } else {%>
+
+                       <td><%=rule.getSource()%></td>
+                    <%}%>
+                <% if (rule.isDisabled()) { %>
+                         <td><strike><%=rule.getDestination()%></strike></td>
+                    <%} else if (rule.getDestType().equals(Rule.SourceDestType.Component.toString())
+                            && componentManager.getComponentName(new JID(rule.getDestination()))!= null) {%>
+                          <td><%=componentManager.getComponentName(new JID(rule.getDestination()))%></td>
+                   <% }else {%>
+                          <td><%=rule.getDestination()%></td>
+                    <%}%>
+                <% if (rule.isDisabled()) { %>
+                         <td><strike><%=rule.getPackeType()%></strike></td>
+                    <%} else {%>
+                        <td><%=rule.getPackeType().getDisplayName()%></td>
+                    <%}%>
+                <% if (rule.isDisabled()) { %>
+                       <td><strike><%=rule.doLog()%></strike></td>
+                    <%} else {%>
+                      <td><%=rule.doLog()%></td>
+                    <%}%>
+
+                <td><a href="delete-rule.jsp?ruleId=<%=rule.getRuleId()%>"><img src="/images/delete-16x16.gif"
+                                                                                width="16" height="16"
+                                                                                border="0"
+                                                                                alt="<fmt:message key="global.click_delete" />"></a>
+                    <!--<a href="rule-form.jsp?beforeId=<%=rule.getRuleId()%>">Before</a>
+                    <a href="rule-form.jsp?afterId=<%=rule.getRuleId()%>">After</a>-->
+                    <%if (rule.getOrder() > 1 && i>0) {%>
+                    <a href="pf-main.jsp?moveOne=<%=rules.get(i-1).getRuleId()%>&ruleId=<%=rule.getRuleId()%>"><img src="arrow_up.png" width="16" height="16" border="0" alt="<fmt:message key="pf.click.up"/>"></a>
+                    <%}%>
+                     <%if (rule.getOrder() != lastOrder) {%>
+                    <a href="pf-main.jsp?moveOne=<%=rules.get(i+1).getRuleId()%>&ruleId=<%=rule.getRuleId()%>"><img src="arrow_down.png" width="16" height="16" border="0" alt="<fmt:message key="pf.click.down"/>"></a>
+                    <%}%>
+                    <a href="rule-edit-form.jsp?edit=<%=rule.getRuleId()%>"><img src="/images/edit-16x16.gif" width="16" height="16" border="0" alt="<fmt:message key="pf.click.edit"/>"></a>
+                </td>
+            </tr>
+            <%
+                i++;
+                } %>
+        </tbody>
+    </table>
+    </div>
+    <input type="button" ONCLICK="window.location.href='rule-form.jsp'" name="create" value="<fmt:message key="pf.create.new.rule"/>">
+
+</body>
+</html>

src/plugins/packetFilter/src/web/scripts/packetfilter.js

+/* Ajax is hard :( */
+
+function HideField(fieldName) {
+   $(fieldName).hide();
+}
+
+function ShowSourceField(decidingElement) {
+   if ($(decidingElement).value.toString() == "Other") {
+        $("SourceOther").show();
+   }
+   else {
+         $("SourceOther").hide();
+   }
+
+   if ($(decidingElement).value.toString() == "Group") {
+        $("SourceGroup").show();
+   }
+   else {
+         $("SourceGroup").hide();
+   }
+
+   if ($(decidingElement).value.toString() == "User") {
+        $("SourceUser").show();
+   }
+   else {
+         $("SourceUser").hide();
+   }
+   if ($(decidingElement).value.toString() == "Component") {
+        $("SourceComponent").show();
+   }
+   else {
+         $("SourceComponent").hide();
+   }
+}
+
+function ShowDestinationField(decidingElement) {
+   if ($(decidingElement).value.toString() == "Other") {
+        $("DestOther").show();
+   }
+   else {
+         $("DestOther").hide();
+   }
+
+   if ($(decidingElement).value.toString() == "Group") {
+        $("DestGroup").show();
+   }
+   else {
+         $("DestGroup").hide();
+   }
+
+   if ($(decidingElement).value.toString() == "User") {
+        $("DestUser").show();
+   }
+   else {
+         $("DestUser").hide();
+   }
+   if ($(decidingElement).value.toString() == "Component") {
+        $("DestComponent").show();
+   }
+   else {
+         $("DestComponent").hide();
+   }
+}
+
+function ShowExtraOptions(decidingElement) {
+   var value =  $(decidingElement).value.toString();
+   if ($(decidingElement).value.toString() =="Redirect") {
+        $("RedirectOptions").show();
+   }
+   else {
+       $("RedirectOptions").hide();
+   }
+}
\ No newline at end of file

src/plugins/packetFilter/src/web/style/packetfilter.css

+/* Maybe some css in here someday */
\ No newline at end of file

src/plugins/packetFilter/src/web/testform.jsp

+<script type="text/javascript"
+    src="/plugins/packetfilter/dwr2/interface/RuleManagerProxy.js"> </script>
+<script type="text/javascript"
+    src="/plugins/packetfilter/dwr2/engine.js"> </script>
+
+<script language="JavaScript" type="text/javascript">
+function handleGetData(str) {
+  alert(str);
+}
+</script>
+
+<body onload="RuleManagerProxy.getRuleById(4, handleGetData);">
+
+
+</body>