securityhandler.java

来自「This is a resource based on j2me embedde」· Java 代码 · 共 572 行 · 第 1/2 页

			try {
				permission = Permissions.getId(permissionStr);
			} catch (SecurityException e) {
				throw new SecurityException(exceptionMsg);
			}
            if (permission >= 0 && permission < permissions.length) {
                switch (permissions[permission]) {
                case Permissions.ALLOW:
                case Permissions.BLANKET_GRANTED:
                    return false;

                case Permissions.BLANKET:
                    /* This level means the question has not been asked yet. */
                    if (askUserForPermission(classSecurityToken, trusted,
                            title, question, app, resource, extraValue)) {

                        Permissions.setPermissionGroup(permissions,
                            permission, Permissions.BLANKET_GRANTED);

                        return true;
                    }

                    Permissions.setPermissionGroup(permissions,
                        permission, Permissions.BLANKET_DENIED);
                    break;

                case Permissions.SESSION:
                    if (sessionValues[permission] == GRANTED) {
                        return false;
                    }

                    if (sessionValues[permission] == DENIED) {
                        break;
                    }

                    if (askUserForPermission(classSecurityToken, trusted,
                            title, question, app, resource, extraValue)) {
                        /*
                         * Save the fact that the question has already
                         * been asked this session.
                         */
                        Permissions.setPermissionGroup(sessionValues,
                            permission, GRANTED);

                        return false;
                    }

                    /*
                     * Save the fact that the question has already
                     * been asked this session.
                     */
                    Permissions.setPermissionGroup(sessionValues,
                        permission, DENIED);
                    break;

                case Permissions.ONESHOT:
                    if (askUserForPermission(classSecurityToken, trusted,
                            title, oneShotQuestion, app, resource,
                            extraValue)) {
                        return false;
                    }

                    break;

                default:
                    // Permissions.NEVER
                    break;
                } // switch
            } // if

            throw new SecurityException(exceptionMsg);
        } // synchronized
    }

    /**
     * Ask the user yes/no permission question.
     *
     * @param token security token with the permission to preempt the
     *        foreground display
     * @param trusted true to display the trusted icon, false to display the
     *                untrusted icon
     * @param title Resource constant for the title of the dialog
     * @param question Resource constant for the question to ask user
     * @param app name of the application to insert into a string
     *        can be null if no %1 a string
     * @param resource string to insert into a string,
     *        can be null if no %2 in a string
     * @param extraValue string to insert into a string,
     *        can be null if no %3 in a string
     *
     * @return true if the user says yes else false
     *
     * @exception InterruptedException if another thread interrupts the
     *   calling thread while this method is waiting to preempt the
     *   display.
     */
    public static boolean askUserForPermission(SecurityToken token,
            boolean trusted, String title, String question, String app,
            String resource, String extraValue) throws InterruptedException {

        PermissionDialog dialog =
            new PermissionDialog(token, trusted, title, question, app,
                                 resource, extraValue);

        return dialog.waitForAnswer();
    }

    /**
     * Initializes the security token for this class, so it can
     * perform actions that a normal MIDlet Suite cannot.
     *
     * @param token security token for this class.
     */
    static void initSecurityToken(SecurityToken token) {
        if (classSecurityToken != null) {
            return;
        }

        classSecurityToken = token;
    }
}

/** Implements security permission dialog. */
class PermissionDialog implements CommandListener {
    /** Caches the display manager reference. */
    private DisplayEventHandler displayEventHandler;

    /** Permission Alert. */
    private Alert alert;

    /** Command object for "Yes" command. */
    private Command yesCmd =
        new Command(Resource.getString(ResourceConstants.YES),
                    Command.OK, 1);
    /** Command object for "No" command. */
    private Command noCmd =
        new Command(Resource.getString(ResourceConstants.NO),
                    Command.BACK, 1);
    /** Holds the preempt token so the form can end. */
    private Object preemptToken;

    /** Holds the answer to the security question. */
    private boolean answer;

    /**
     * Construct permission dialog.
     * <p>
     * The title, question, and answer strings will be translated,
     * if a string resource is available.
     * Since the strings can have substitution token in them, if there is a
     * "%" it must changed to "%%". If a string has a %1, the app parameter
     * will be substituted for it. If a string has a "%2, the resource
     * parameter will be substituted for it. If a string has a %3, the
     * extraValue parameter will be substituted for it.
     *
     * @param token security token with the permission to preempt the
     *        foreground display
     * @param trusted true to display the trusted icon, false to display the
     *                untrusted icon
     * @param title Resource constant for the title of the dialog
     * @param question Resource constant for the question to ask user
     * @param app name of the application to insert into a string
     *        can be null if no %1 a string
     * @param resource string to insert into a string,
     *        can be null if no %2 in a string
     * @param extraValue string to insert into a string,
     *        can be null if no %3 in a string
     *
     * @exception InterruptedException if another thread interrupts the
     *   calling thread while this method is waiting to preempt the
     *   display.
     */
    PermissionDialog(SecurityToken token, boolean trusted, String title,
            String question, String app, String resource, String extraValue)
            throws InterruptedException {
        String[] substitutions = {app, resource, extraValue};
        String iconFilename;
        RandomAccessStream stream;
        byte[] rawPng;
        Image icon;
        String configRoot = File.getConfigRoot(Constants.INTERNAL_STORAGE_ID);

        alert = new Alert(Resource.getString(title, substitutions));

        displayEventHandler =
            DisplayEventHandlerFactory.getDisplayEventHandler(token);

        if (trusted) {
            iconFilename = configRoot + "trusted_icon.png";
        } else {
            iconFilename = configRoot + "untrusted_icon.png";
        }

        stream = new RandomAccessStream(token);
        try {
            stream.connect(iconFilename, Connector.READ);
            rawPng = new byte[stream.getSizeOf()];
            stream.readBytes(rawPng, 0, rawPng.length);
            stream.disconnect();
            icon = Image.createImage(rawPng, 0, rawPng.length);
            alert.setImage(icon);
        } catch (java.io.IOException noImage) {
        }

        alert.setString(Resource.getString(question, substitutions));
        alert.addCommand(noCmd);
        alert.addCommand(yesCmd);
        alert.setCommandListener(this);
        preemptToken = displayEventHandler.preemptDisplay(alert, true);
    }

    /**
     * Waits for the user's answer.
     *
     * @return user's answer
     */
    boolean waitForAnswer() {
        synchronized (this) {
            if (preemptToken == null) {
                return false;
            }

            if (EventQueue.isDispatchThread()) {
                // Developer programming error
                throw new RuntimeException(
                "Blocking call performed in the event thread");
            }

            try {
                wait();
            } catch (Throwable t) {
                return false;
            }

            return answer;
        }
    }

    /**
     * Sets the user's answer and notifies waitForAnswer and
     * ends the form.
     *
     * @param theAnswer user's answer
     */
    private void setAnswer(boolean theAnswer) {
        synchronized (this) {
            answer = theAnswer;

            /*
             * Since this may be the only display, clear the alert,
             * so the user will not be confused by alert text still
             * displaying.
             *
             * The case should happen when running TCK test MIDlets in
             * SVM mode.
             */
            alert.setTitle(null);
            alert.setString(null);
            alert.setImage(null);
            alert.addCommand(new Command("", 1, 1));
            alert.removeCommand(noCmd);
            alert.removeCommand(yesCmd);

            displayEventHandler.donePreempting(preemptToken);

            notify();
        }

    }

    /**
     * Respond to a command issued on security question form.
     *
     * @param c command activated by the user
     * @param s the Displayable the command was on.
     */
    public void commandAction(Command c, Displayable s) {
        if (c == yesCmd) {
            setAnswer(true);
            return;
        }

        setAnswer(false);
    }
}