servicepermission.java

OSGI这是一个中间件,与UPNP齐名,是用于移植到嵌入式平台之上

            }

            actions = sb.toString();
        }

        return(actions);
    }

    /**
     * Returns a new <tt>PermissionCollection</tt> object for storing
     * <tt>ServicePermission<tt> objects.
     *
     * @return A new <tt>PermissionCollection</tt> object suitable for storing
     * <tt>ServicePermission</tt> objects.
     */
    public PermissionCollection newPermissionCollection()
    {
        return (new ServicePermissionCollection());
    }

    /**
     * Determines the equalty of two ServicePermission objects.
     *
     * Checks that specified object has the same class name
     * and action as this <tt>ServicePermission</tt>.
     *
     * @param obj The object to test for equality.
     * @return true if obj is a <tt>ServicePermission</tt>, and has the
     * same class name and actions as this <tt>ServicePermission</tt> object; <tt>false</tt> otherwise.
     */
    public boolean equals(Object obj)
    {
        if (obj == this)
        {
            return(true);
        }

        if (!(obj instanceof ServicePermission))
        {
            return(false);
        }

        ServicePermission p = (ServicePermission) obj;

        return((action_mask == p.action_mask) &&
        getName().equals(p.getName()));
    }

    /**
     * Returns the hash code value for this object.
     *
     * @return Hash code value for this object.
     */

    public int hashCode()
    {
        return(getName().hashCode() ^ getActions().hashCode());
    }

    /**
     * Returns the current action mask.
     * Used by the ServicePermissionCollection object.
     *
     * @return The actions mask.
     */
    int getMask()
    {
        return (action_mask);
    }

    /**
     * WriteObject is called to save the state of the ServicePermission
     * to a stream. The actions are serialized, and the superclass
     * takes care of the name.
     */

    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();
    }

    /**
     * readObject is called to restore the state of the ServicePermission from
     * a stream.
     */
    private synchronized void readObject(java.io.ObjectInputStream s)
        throws IOException, ClassNotFoundException
    {
        // Read in the action, then initialize the rest
        s.defaultReadObject();
        init(getMask(actions));
    }
}

/**
 * Stores a set of ServicePermission permissions.
 *
 * @see java.security.Permission
 * @see java.security.Permissions
 * @see java.security.PermissionCollection
 */

final class ServicePermissionCollection extends PermissionCollection
{

    /**
     * Table of permissions.
     *
     * @serial
     */
    private Hashtable permissions;

    /**
     * Boolean saying if "*" is in the collection.
     *
     * @serial
     */
    private boolean all_allowed;

    /**
     * Creates an empty ServicePermissions object.
     *
     */

    public ServicePermissionCollection()
    {
        permissions = new Hashtable();
        all_allowed = false;
    }

    /**
     * Adds a permission to the <tt>ServicePermission</tt> objects using the key for the hash as
     * the name.
     *
     * @param permission The Permission object to add.
     *
     * @exception IllegalArgumentException If the permission is not a ServicePermission object.
     *
     * @exception SecurityException If this <tt>ServicePermissionCollection</tt> object has been marked read-only.
     */

    public void add(Permission permission)
    {
        if (! (permission instanceof ServicePermission))
            throw new IllegalArgumentException("invalid permission: "+
                                               permission);
        if (isReadOnly())
            throw new SecurityException("attempt to add a Permission to a " +
                    "readonly PermissionCollection");

        ServicePermission sp = (ServicePermission) permission;
        String name = sp.getName();

        ServicePermission existing =
        (ServicePermission) permissions.get(name);

        if (existing != null)
        {
            int oldMask = existing.getMask();
            int newMask = sp.getMask();
            if (oldMask != newMask)
            {
                permissions.put(name,
                new ServicePermission(name,
                            oldMask | newMask));
            }
        }
        else
        {
            permissions.put(name, permission);
        }

        if (!all_allowed)
        {
            if (name.equals("*"))
                all_allowed = true;
        }
    }

    /**
     * Determines if a set of permissions implies the permissions
     * expressed in <tt>permission</tt>.
     *
     * @param p The Permission object to compare.
     *
     * @return <tt>true</tt> if <tt>permission</tt> is a proper subset of a permission in
     * the set; <tt>false</tt> otherwise.
     */

    public boolean implies(Permission permission)
    {
        if (!(permission instanceof ServicePermission))
            return (false);

        ServicePermission sp = (ServicePermission) permission;
        ServicePermission x;

        int desired = sp.getMask();
        int effective = 0;

        // short circuit if the "*" Permission was added
        if (all_allowed)
        {
            x = (ServicePermission) permissions.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 = sp.getName();

        x = (ServicePermission) permissions.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) + "*";
            x = (ServicePermission) permissions.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);
    }

    /**
     * Returns an enumeration of all the <tt>ServicePermission</tt> objects in the
     * container.
     *
     * @return Enumeration of all the ServicePermission objects.
     */

    public Enumeration elements()
    {
        return (permissions.elements());
    }
}