packagepermission.java

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

/*
 * Copyright (c) The Open Services Gateway Initiative (2000, 2002).
 * All Rights Reserved.
 *
 * Implementation of certain elements of the Open Services Gateway Initiative
 * (OSGI) Specification may be subject to third party intellectual property
 * rights, including without limitation, patent rights (such a third party may
 * or may not be a member of OSGi). OSGi is not responsible and shall not be
 * held responsible in any manner for identifying or failing to identify any or
 * all such third party intellectual property rights.
 *
 * This document and the information contained herein are provided on an "AS
 * IS" basis and OSGI DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL
 * NOT INFRINGE ANY RIGHTS AND ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR
 * FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL OSGI BE LIABLE FOR ANY
 * LOSS OF PROFITS, LOSS OF BUSINESS, LOSS OF USE OF DATA, INTERRUPTION OF
 * BUSINESS, OR FOR DIRECT, INDIRECT, SPECIAL OR EXEMPLARY, INCIDENTIAL,
 * PUNITIVE OR CONSEQUENTIAL DAMAGES OF ANY KIND IN CONNECTION WITH THIS
 * DOCUMENT OR THE INFORMATION CONTAINED HEREIN, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH LOSS OR DAMAGE.
 *
 * All Company, brand and product names may be trademarks that are the sole
 * property of their respective owners. All rights reserved.
 */

package org.osgi.framework;

import java.io.IOException;
import java.util.Hashtable;
import java.util.Enumeration;
import java.security.Permission;
import java.security.BasicPermission;
import java.security.PermissionCollection;

/**
 * A bundle's authority to import or export a package.
 *
 * <p>A package is a dot-separated string that defines a fully qualified Java
 * package.
 * <p>For example:
 * <pre>
 * <tt>org.osgi.service.http</tt>
 * </pre>
 * <p><tt>PackagePermission</tt> has two actions: <tt>EXPORT</tt> and <tt>IMPORT</tt>.
 * The <tt>EXPORT</tt> action implies the <tt>IMPORT</tt> action.
 *
 * @version $Revision: 1.1.1.1 $
 * @author Open Services Gateway Initiative
 */

public final class PackagePermission extends BasicPermission
{

    /**
     * The action string <tt>export</tt>.
     */
    public final static String EXPORT = "export";

    /**
     * The action string <tt>import</tt>.
     */
    public final static String IMPORT = "import";

    private final static int ACTION_EXPORT      = 0x00000001;
    private final static int ACTION_IMPORT      = 0x00000002;
    private final static int ACTION_ALL         = ACTION_EXPORT | ACTION_IMPORT;
    private final static int ACTION_NONE        = 0;
    private final static int ACTION_ERROR       = 0x80000000;

    /**
     * The actions mask.
     */
    private transient int action_mask = ACTION_NONE;

    /**
     * The actions in canonical form.
     *
     * @serial
     */
    private String actions = null;

    /**
     * Defines the authority to import and/or export a package within the OSGi environment.
     * <p>The name is specified as a normal Java package name: a dot-separated string. Wildcards may be used.
     * For example:
     * <pre>
     * org.osgi.service.http
     * javax.servlet.*
     * *
     * </pre>
     * <p>Package Permissions are granted over all possible versions of a package.
     *
     * A bundle that needs to export a package must have the appropriate <tt>PackagePermission</tt>
     * for that package; similarly, a bundle that needs to import a package must have the appropriate
     * <tt>PackagePermssion</tt> for that package.
     * <p>Permission is granted for both classes and resources.
     * @param name Package name.
     * @param actions <tt>EXPORT</tt>, <tt>IMPORT</tt> (canonical order).
     */

    public PackagePermission(String name, String actions)
    {
        this(name, getMask(actions));
    }

    /**
     * Package private constructor used by PackagePermissionCollection.
     *
     * @param name class name
     * @param action mask
     */
    PackagePermission(String name, int mask)
    {
        super(name);
        init(mask);
    }

    /**
     * Called by constructors and when deserialized.
     *
     * @param action mask
     */
    private void init(int mask)
    {
        if ((mask == ACTION_NONE) ||
            ((mask & ACTION_ALL) != mask))
        {
            throw new IllegalArgumentException("invalid action string");
        }

        action_mask = mask;
    }

    /**
     * Parse action string into action mask.
     *
     * @param actions Action string.
     * @return action mask.
     */
    private static int getMask(String actions)
    {
        boolean seencomma = false;

        int mask = ACTION_NONE;

        if (actions == null)
        {
            return (mask);
        }

        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 >= 5 && (a[i-5] == 'i' || a[i-5] == 'I') &&
                (a[i-4] == 'm' || a[i-4] == 'M') &&
                (a[i-3] == 'p' || a[i-3] == 'P') &&
                (a[i-2] == 'o' || a[i-2] == 'O') &&
                (a[i-1] == 'r' || a[i-1] == 'R') &&
                (a[i] == 't' || a[i] == 'T'))
            {
                matchlen = 6;
                mask |= ACTION_IMPORT;

            }
            else if (i >= 5 && (a[i-5] == 'e' || a[i-5] == 'E') &&
                     (a[i-4] == 'x' || a[i-4] == 'X') &&
                     (a[i-3] == 'p' || a[i-3] == 'P') &&
                     (a[i-2] == 'o' || a[i-2] == 'O') &&
                     (a[i-1] == 'r' || a[i-1] == 'R') &&
                     (a[i] == 't' || a[i] == 'T'))
            {
                matchlen = 6;
                mask |= ACTION_EXPORT | ACTION_IMPORT;

            }
            else
            {
                // parse error
                throw new IllegalArgumentException("invalid permission: " +
                                                   actions);
            }

            // make sure we didn't just match the tail of a word
            // like "ackbarfimport".  Also, skip to the comma.
            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;
        }

        if (seencomma)
        {
            throw new IllegalArgumentException("invalid permission: " +
                                               actions);
        }

        return (mask);
    }

    /**
     * Determines if the specified permission is implied by this object.
     *
     * <p>This method checks that the package name of the target is implied by the package name
     * of this object. The list of <tt>PackagePermission</tt> actions must either match or allow
     * for the list of the target object to imply the target <tt>PackagePermission</tt> action.
     * <p>The permission to export a package implies the permission to import the named package.
     * <pre>
     * x.y.*,"export" -> x.y.z,"export" is true
     * *,"import" -> x.y, "import"      is true
     * *,"export" -> x.y, "import"      is true
     * x.y,"export" -> x.y.z, "export"  is false
     * </pre>
     *
     * @param p The target permission to interrogate.
     * @return <tt>true</tt> if the specified <tt>PackagePermission</tt> action is implied by
     * this object; <tt>false</tt> otherwise.
     */

    public boolean implies(Permission p)
    {
        if (p instanceof PackagePermission)
        {
            PackagePermission target = (PackagePermission) p;

            return(((action_mask & target.action_mask)==target.action_mask) &&
                   super.implies(p));
        }

        return(false);
    }

    /**
     * Returns the canonical string representation of the <tt>PackagePermission</tt> actions.
     *
     * <p>Always returns present <tt>PackagePermission</tt> actions in the following order:
     * <tt>EXPORT</tt>, <tt>IMPORT</tt>.
     * @return Canonical string representation of the <tt>PackagePermission</tt> actions.
     */

    public String getActions()
    {
        if (actions == null)
        {
            StringBuffer sb = new StringBuffer();
            boolean comma = false;

            if ((action_mask & ACTION_EXPORT) == ACTION_EXPORT)
            {