org/objectweb/proactive/ext/security/Communication.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.ext.security;

import java.io.Serializable;

import org.objectweb.proactive.ext.security.exceptions.IncompatiblePolicyException;


public class Communication implements Serializable {
    public static int REQUIRED = 1;
    public static int DENIED = -1;
    public static int OPTIONAL = 0;
    public static int ALLOWED = 1;

    /* indicates if authentication is required,optional or denied */
    private int authentication;

    /* indicates if confidentiality is required,optional or denied */
    private int confidentiality;

    /* indicates if integrity is required,optional or denied */
    private int integrity;

    /* indicates if communication between active objects is allowed or not */
    private int communication;
    private int migration;
    private int aoCreation;

    public Communication() {
        authentication = 0;
        confidentiality = 0;
        integrity = 0;
        communication = 1;
        migration = 1;
        aoCreation = 1;
    }

    public Communication(int authentication, int confidentiality, int integrity) {
        this.authentication = authentication;
        this.confidentiality = confidentiality;
        this.integrity = integrity;
    }

    public boolean isAuthenticationEnabled() {
        return authentication == 1;
    }

    public boolean isConfidentialityEnabled() {
        return confidentiality == 1;
    }

    public boolean isIntegrityEnabled() {
        return integrity == 1;
    }

    public boolean isAuthenticationForbidden() {
        return authentication == -1;
    }

    public boolean isConfidentialityForbidden() {
        return confidentiality == -1;
    }

    public boolean isIntegrityForbidden() {
        return integrity == -1;
    }

    public boolean isCommunicationAllowed() {
        return communication == 1;
    }

    public String toString() {
        return "Com : " + communication + " Auth : " + authentication +
        " Conf : " + confidentiality + " Integrity : " + integrity + "\n";
    }

    public void setMigration(int i) {
        migration = i;
    }

    public int getMigration() {
        return migration;
    }

    public static Communication computeCommunication(Communication from,
        Communication to) throws IncompatiblePolicyException {
        if (from.isCommunicationAllowed() && to.isCommunicationAllowed()) {
            if (((from.authentication == REQUIRED) &&
                    (to.authentication == DENIED)) ||
                    ((from.confidentiality == REQUIRED) &&
                    (to.confidentiality == DENIED)) ||
                    ((from.integrity == REQUIRED) && (to.integrity == DENIED)) ||
                    ((from.authentication == DENIED) &&
                    (to.authentication == REQUIRED)) ||
                    ((from.confidentiality == DENIED) &&
                    (to.confidentiality == REQUIRED)) ||
                    ((from.integrity == DENIED) && (to.integrity == REQUIRED))) {
                throw new IncompatiblePolicyException("incompatible policies");
            }
        }

        return new Communication(from.authentication + to.authentication,
            from.confidentiality + to.confidentiality,
            from.integrity + to.integrity);
    }

    public void setAOCreation(int aocreation) {
        this.aoCreation = aocreation;
    }

    public int getAOCreation() {
        return this.aoCreation;
    }

    public int getCommunication() {
        return communication;
    }

    public void setCommunication(int i) {
        communication = i;
    }
}

---