/*

   * Copyright 1997-2003 Sun Microsystems, Inc.  All Rights Reserved.

   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

   *

   * This code is free software; you can redistribute it and/or modify it

   * under the terms of the GNU General Public License version 2 only, as

   * published by the Free Software Foundation.  Sun designates this

   * particular file as subject to the "Classpath" exception as provided

   * by Sun in the LICENSE file that accompanied this code.

  *

  * This code 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 General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

  * CA 95054 USA or visit www.sun.com if you need additional information or

  * have any questions.

  */

 package java.util;

 import java.io.Serializable;

 import java.io.IOException;

 import java.security.*;

 import java.util.Map;

 import java.util.HashMap;

 import java.util.Enumeration;

 import java.util.Hashtable;

 import java.util.Collections;

 import java.io.ObjectStreamField;

 import java.io.ObjectOutputStream;

 import java.io.ObjectInputStream;

 import java.io.IOException;

 import sun.security.util.SecurityConstants;

 public final class PropertyPermission extends BasicPermission {

    

     private final static int READ    = 0x1;

    

    private final static int WRITE   = 0x2;
    

    private final static int ALL     = READ|WRITE;
    

    private final static int NONE    = 0x0;

    

    private transient int mask;

    

    private String actions; // Left null as long as possible, then

                            // created and re-used in the getAction function.

    private void init(int mask)

    {

        if ((mask & ALL) != mask)

                throw new IllegalArgumentException("invalid actions mask");

        if (mask == NONE)

                throw new IllegalArgumentException("invalid actions mask");

        if (getName() == null)

                throw new NullPointerException("name can't be null");

        this.mask = mask;

    }

    

    public PropertyPermission(String name, String actions)

    {

        super(name,actions);

        init(getMask(actions));

    }

    

    public boolean implies(Permission p) {

        if (!(p instanceof PropertyPermission))

            return false;

        PropertyPermission that = (PropertyPermission) p;

        // we get the effective mask. i.e., the "and" of this and that.

        // They must be equal to that.mask for implies to return true.

        return ((this.mask & that.mask) == that.mask) && super.implies(that);

    }


    

    public boolean equals(Object obj) {

        if (obj == this)

            return true;

        if (! (obj instanceof PropertyPermission))

            return false;

        PropertyPermission that = (PropertyPermission) obj;

        return (this.mask == that.mask) &&

            (this.getName().equals(that.getName()));

    }

    

    public int hashCode() {

        return this.getName().hashCode();

    }


    

    private static int getMask(String actions) {

        int mask = NONE;

        if (actions == null) {

            return mask;

        }

        // Check against use of constants (used heavily within the JDK)

        if (actions == SecurityConstants.PROPERTY_READ_ACTION) {

            return READ;

        } if (actions == SecurityConstants.PROPERTY_WRITE_ACTION) {

            return WRITE;

        } else if (actions == SecurityConstants.PROPERTY_RW_ACTION) {

            return READ|WRITE;

        }

        char[] a = actions.toCharArray();

        int i = a.length - 1;

        if (i < 0)

            return mask;

        while (i != -1) {

            char c;

            // skip whitespace

            while ((i!=-1) && ((c = a[i]) == ' ' ||

                               c == '\r' ||

                               c == '\n' ||

                               c == '\f' ||

                               c == '\t'))

                i--;

            // check for the known strings

            int matchlen;

            if (i >= 3 && (a[i-3] == 'r' || a[i-3] == 'R') &&

                          (a[i-2] == 'e' || a[i-2] == 'E') &&

                          (a[i-1] == 'a' || a[i-1] == 'A') &&

                          (a[i] == 'd' || a[i] == 'D'))

            {

                matchlen = 4;

                mask |= READ;

            } else if (i >= 4 && (a[i-4] == 'w' || a[i-4] == 'W') &&

                                 (a[i-3] == 'r' || a[i-3] == 'R') &&

                                 (a[i-2] == 'i' || a[i-2] == 'I') &&

                                 (a[i-1] == 't' || a[i-1] == 'T') &&

                                 (a[i] == 'e' || a[i] == 'E'))

            {

                matchlen = 5;

                mask |= WRITE;

            } else {

                // parse error

                throw new IllegalArgumentException(

                        "invalid permission: " + actions);

            }

            // make sure we didn't just match the tail of a word

            // like "ackbarfaccept".  Also, skip to the comma.

            boolean seencomma = false;

            while (i >= matchlen && !seencomma) {

                switch(a[i-matchlen]) {

                case ',':

                    seencomma = true;

                    /*FALLTHROUGH*/

                case ' ': case '\r': case '\n':

                case '\f': case '\t':

                    break;

                default:

                    throw new IllegalArgumentException(

                            "invalid permission: " + actions);

                }

                i--;

            }

            // point i at the location of the comma minus one (or -1).

            i -= matchlen;

        }

        return mask;

    }


    

    static String getActions(int mask)

    {

        StringBuilder sb = new StringBuilder();

        boolean comma = false;

        if ((mask & READ) == READ) {

            comma = true;

            sb.append("read");

        }

        if ((mask & WRITE) == WRITE) {

            if (comma) sb.append(',');

            else comma = true;

            sb.append("write");

        }

        return sb.toString();

    }

    

    public String getActions()

    {

        if (actions == null)

            actions = getActions(this.mask);

        return actions;

    }

    

    int getMask() {

        return mask;

    }

    

    public PermissionCollection newPermissionCollection() {

        return new PropertyPermissionCollection();

    }

    private static final long serialVersionUID = 885438825399942851L;

    

    private synchronized void writeObject(java.io.ObjectOutputStream s)

        throws IOException

    {

        // Write out the actions. The superclass takes care of the name

        // call getActions to make sure actions field is initialized

        if (actions == null)

            getActions();

        s.defaultWriteObject();

    }

    

    private synchronized void readObject(java.io.ObjectInputStream s)

         throws IOException, ClassNotFoundException

    {

        // Read in the action, then initialize the rest

        s.defaultReadObject();

        init(getMask(actions));

    }

}

final class PropertyPermissionCollection extends PermissionCollection

implements Serializable

{

    

    private transient Map perms;

    

    // No sync access; OK for this to be stale.

    private boolean all_allowed;

    

    public PropertyPermissionCollection() {

        perms = new HashMap(32);     // Capacity for default policy

        all_allowed = false;

    }

    

    public void add(Permission permission)

    {

        if (! (permission instanceof PropertyPermission))

            throw new IllegalArgumentException("invalid permission: "+

                                               permission);

        if (isReadOnly())

            throw new SecurityException(

                "attempt to add a Permission to a readonly PermissionCollection");

        PropertyPermission pp = (PropertyPermission) permission;

        String propName = pp.getName();

        synchronized (this) {

            PropertyPermission existing = (PropertyPermission) perms.get(propName);

            if (existing != null) {

                int oldMask = existing.getMask();

                int newMask = pp.getMask();

                if (oldMask != newMask) {

                    int effective = oldMask | newMask;

                    String actions = PropertyPermission.getActions(effective);

                    perms.put(propName, new PropertyPermission(propName, actions));

                }

            } else {

                perms.put(propName, permission);

            }

        }

        if (!all_allowed) {

            if (propName.equals("*"))

                all_allowed = true;

        }

    }

    

    public boolean implies(Permission permission)

    {

        if (! (permission instanceof PropertyPermission))

                return false;

        PropertyPermission pp = (PropertyPermission) permission;

        PropertyPermission x;

        int desired = pp.getMask();

        int effective = 0;

        // short circuit if the "*" Permission was added

        if (all_allowed) {

            synchronized (this) {

                x = (PropertyPermission) perms.get("*");

            }

            if (x != null) {

                effective |= x.getMask();

                if ((effective & desired) == desired)

                    return true;

            }

        }

        // strategy:

        // Check for full match first. Then work our way up the

        // name looking for matches on a.b.*

        String name = pp.getName();

        //System.out.println("check "+name);

        synchronized (this) {

            x = (PropertyPermission) perms.get(name);

        }

        if (x != null) {

            // we have a direct hit!

            effective |= x.getMask();

            if ((effective & desired) == desired)

                return true;

        }

        // work our way up the tree...

        int last, offset;

        offset = name.length()-1;

        while ((last = name.lastIndexOf(".", offset)) != -1) {

            name = name.substring(0, last+1) + "*";

            //System.out.println("check "+name);

            synchronized (this) {

                x = (PropertyPermission) perms.get(name);

            }

            if (x != null) {

                effective |= x.getMask();

                if ((effective & desired) == desired)

                    return true;

            }

            offset = last -1;

        }

        // we don't have to check for "*" as it was already checked

        // at the top (all_allowed), so we just return false

        return false;

    }

    

    public Enumeration elements() {

        // Convert Iterator of Map values into an Enumeration

        synchronized (this) {

            return Collections.enumeration(perms.values());

        }

    }

    private static final long serialVersionUID = 7015263904581634791L;

    // Need to maintain serialization interoperability with earlier releases,

    // which had the serializable field:

    //

    // Table of permissions.

    //

    // @serial

    //

    // private Hashtable permissions;

    private static final ObjectStreamField[] serialPersistentFields = {

        new ObjectStreamField("permissions", Hashtable.class),

        new ObjectStreamField("all_allowed", Boolean.TYPE),

    };

    

    /*

     * Writes the contents of the perms field out as a Hashtable for

     * serialization compatibility with earlier releases. all_allowed

     * unchanged.

     */

    private void writeObject(ObjectOutputStream out) throws IOException {

        // Don't call out.defaultWriteObject()

        // Copy perms into a Hashtable

        Hashtable permissions = new Hashtable(perms.size()*2);

        synchronized (this) {

            permissions.putAll(perms);

        }

        // Write out serializable fields

        ObjectOutputStream.PutField pfields = out.putFields();

        pfields.put("all_allowed", all_allowed);

        pfields.put("permissions", permissions);

        out.writeFields();

    }

    /*

     * Reads in a Hashtable of PropertyPermissions and saves them in the

     * perms field. Reads in all_allowed.

     */

    private void readObject(ObjectInputStream in) throws IOException,

    ClassNotFoundException {

        // Don't call defaultReadObject()

        // Read in serialized fields

        ObjectInputStream.GetField gfields = in.readFields();

        // Get all_allowed

        all_allowed = gfields.get("all_allowed", false);

        // Get permissions

        Hashtable permissions = (Hashtable)gfields.get("permissions", null);

        perms = new HashMap(permissions.size()*2);

        perms.putAll(permissions);

    }

}