ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/experimental/server/ACL/ACL.java
(Generate patch)

Comparing experimental/server/ACL/ACL.java (file contents):
Revision 1.3 by tdb, Fri Dec 21 16:49:18 2001 UTC vs.
Revision 1.7 by tdb, Mon Dec 31 01:49:13 2001 UTC

# Line 4 | Line 4
4   //---IMPORTS---
5   import uk.org.iscream.cms.server.util.*;
6   import java.util.ArrayList;
7 + import java.util.StringTokenizer;
8   import java.net.InetAddress;
9 + import java.io.Serializable;
10  
11   /**
12   * Access Control List for use primarily
# Line 17 | Line 19 | import java.net.InetAddress;
19   * @author  $Author$
20   * @version $Id$
21   */
22 < public class ACL {
22 > public class ACL implements Serializable {
23  
24   //---FINAL ATTRIBUTES---
25  
# Line 74 | Line 76 | public class ACL {
76       * param expression what this rule matches using wildcards
77       */
78      public void add(boolean allow, String expression) {
79 <        _acl.add(new ACLRule(allow, expression));
79 >        // default to expecting it to be an IP
80 >        // we will try to disprove this :)
81 >        boolean ip = true;
82 >        short[] ipaddr = {-1, -1, -1, -1};
83 >        int i = 0;
84 >        String s = "";
85 >        // tokenize the expression on fullstops, so we can break
86 >        // up the quads of an IP (if it's an IP!)
87 >        StringTokenizer st = new StringTokenizer(expression, ".");
88 >        while(st.hasMoreTokens() && i++ < 4) {
89 >            s = st.nextToken();
90 >            // if it's a wildcard, we'll skip to the next one
91 >            // as no more checks are required
92 >            if(s.equals("*")) {
93 >                continue;
94 >            }
95 >            // attempt to parse it into a short
96 >            try {
97 >                short n = Short.parseShort(s);
98 >                // if it's an int but outside of the
99 >                // valid range, it can't be an IP
100 >                if(n < 0 || n > 255) {
101 >                    ip = false;
102 >                    // give up checking further
103 >                    break;
104 >                }
105 >                ipaddr[i-1] = n;
106 >            }
107 >            // if it didn't parse as an int it can't be an IP
108 >            catch (NumberFormatException e) {
109 >                ip = false;
110 >                // give up checking further
111 >                break;
112 >            }
113 >        }
114 >        // we've done 4 parts, so if there's any
115 >        // more this can't be an IP
116 >        if(st.hasMoreTokens()) {
117 >            ip = false;
118 >        }
119 >        // if we've done less than 4, see if the last one
120 >        // was a wildcard - if it isn't then it's not an IP
121 >        //   -- this allows 129.12.*
122 >        if(i < 4 && !s.equals("*")) {
123 >            ip = false;
124 >        }
125 >        // if we had one or less entries it can't be an IP
126 >        //   -- this disallows * matching as an IP due
127 >        //      to the rule above
128 >        if(i <= 1) {
129 >            ip = false;
130 >        }
131 >        // finally print out what we've found.
132 >        System.out.println("IP("+ip+"): "+expression);
133 >        if(ip) {
134 >            for(int j=0; j < ipaddr.length; j++) {
135 >                System.out.print(ipaddr[j] + " ");
136 >            }
137 >            System.out.println();
138 >        }
139 >        _acl.add(new ACLRule(allow, expression, ipaddr, ip));
140      }
141      
142      /**
# Line 107 | Line 169 | public class ACL {
169       * @return whether the InetAddress was permitted by the ACL
170       */
171      public boolean check(InetAddress address) {
172 +        String hostname = address.getHostName();
173 +        String ip = address.getHostAddress();
174 +        short[] ipaddr = ipStringToShort(ip);
175          for(int i=0; i < _acl.size(); i++) {
176              ACLRule rule = (ACLRule) _acl.get(i);
177 <            if(StringUtils.wildcardCheck(address.getHostName(), rule._expression)) {
178 <                return rule._allow;
177 >            if(rule._iprule) {
178 >                System.out.println("checking ip rule "+rule._expression);
179 >                //if(StringUtils.wildcardCheck(ip, rule._expression)) {
180 >                if(compareShorts(ipaddr, rule._ipaddr)) {
181 >                    return rule._allow;
182 >                }
183              }
184 <            if(StringUtils.wildcardCheck(address.getHostAddress(), rule._expression)) {
185 <                return rule._allow;
184 >            else {
185 >                System.out.println("checking name rule: "+rule._expression);
186 >                if(StringUtils.wildcardCheck(hostname, rule._expression)) {
187 >                    return rule._allow;
188 >                }
189              }
190 +            
191          }
192          return _defaultMode;
193      }
194      
195      /**
196 <     * Gets the ACL as a String for debugging.
196 >     * Gives a String representation of this ACL.
197       *
198       * @return A String representation of this ACL.
199       */
200 <    public String getStringACL() {
201 <        String acl = "";
200 >    public String toString() {
201 >        StringBuffer acl = new StringBuffer();
202 >        acl.append("{");
203          for(int i=0; i < _acl.size(); i++) {
204 <            ACLRule rule = (ACLRule) _acl.get(i);
205 <            if(rule._allow) {
132 <                acl += "ALLOW:" + rule._expression + " ";
133 <            }
134 <            else {
135 <                acl += "DENY:" + rule._expression + " ";
136 <            }
204 >            acl.append((ACLRule) _acl.get(i));
205 >            acl.append(",");
206          }
207          if(_defaultMode) {
208 <            acl += "DEFAULT:ALLOW";
208 >            acl.append("DEFAULT=ALLOW");
209          }
210          else {
211 <            acl += "DEFAULT:DENY";
211 >            acl.append("DEFAULT=DENY");
212          }
213 <        return acl;
213 >        acl.append("}");
214 >        return acl.toString();
215      }
146    
147    /**
148     * Overrides the {@link java.lang.Object#toString() Object.toString()}
149     * method to provide clean logging (every class should have this).
150     *
151     * This uses the uk.org.iscream.cms.server.util.FormatName class
152     * to format the toString()
153     *
154     * @return the name of this class and its CVS revision
155     */
156    public String toString() {
157        return FormatName.getName(
158            _name,
159            getClass().getName(),
160            REVISION);
161    }
216  
217   //---PRIVATE METHODS---
218  
219 +    private short[] ipStringToShort(String ip) {
220 +        short[] ipaddr = {-1, -1, -1, -1};
221 +        StringTokenizer st = new StringTokenizer(ip, ".");
222 +        for(int i=0; i < 4 && st.hasMoreTokens(); i++) {
223 +            try {
224 +                ipaddr[i] = Short.parseShort(st.nextToken());
225 +            }
226 +            catch(NumberFormatException e) {
227 +                // do nothing?
228 +            }
229 +        }
230 +        return ipaddr;
231 +    }
232 +    
233 +    private boolean compareShorts(short[] first, short[] second) {
234 +        if(first.length != second.length) {
235 +            System.out.println("not equal length");
236 +            return false;
237 +        }
238 +        for(int i=0; i < first.length; i++) {
239 +            // -- might want to consider specify which is the wildcard one?
240 +            System.out.println(i + ":" + first[i] + "," + second[i]);
241 +            if(first[i] == -1 || second[i] == -1) {
242 +                continue;
243 +            }
244 +            if(first[i] != second[i]) {
245 +                System.out.println("not equal");
246 +                return false;
247 +            }
248 +        }
249 +        System.out.println("equal");
250 +        return true;
251 +    }
252 +
253   //---ACCESSOR/MUTATOR METHODS---
254  
255   //---ATTRIBUTES---
# Line 194 | Line 282 | public class ACL {
282      /**
283       * Wrapper class for an ACL rule.
284       */
285 <    private class ACLRule {
285 >    private class ACLRule implements Serializable {
286          
287          /**
288           * Construct an ACL rule.
289           *
290           * @param allow whether this is an ALLOW or DENY rule
291           * @param expression what this rule matches
292 +         * @param iprule whether this is an IP rule
293           */
294 <        private ACLRule(boolean allow, String expression) {
294 >        private ACLRule(boolean allow, String expression, short[] ipaddr, boolean iprule) {
295              _allow = allow;
296              _expression = expression;
297 +            _ipaddr = ipaddr;
298 +            _iprule = iprule;
299          }
300          
301          /**
302 +         * Returns a String representation of this rule.
303 +         *
304 +         * @return A String representation of this rule.
305 +         */
306 +        public String toString() {
307 +            if(_allow) {
308 +                return _expression + "=ALLOW";
309 +            }
310 +            else {
311 +                return _expression + "=DENY";
312 +            }
313 +        }
314 +        
315 +        /**
316           * Whether this is an ALLOW or DENY rule.
317           */
318          private boolean _allow;
# Line 216 | Line 321 | public class ACL {
321           * What this rule matches.
322           */
323          private String _expression;
324 +        
325 +        private short[] _ipaddr;
326 +        
327 +        /**
328 +         * Whether this is an IP rule.
329 +         */
330 +        private boolean _iprule;
331          
332      }
333  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines