/*

 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.rmi.server;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInput;

import java.io.ObjectInputStream;

import java.io.OutputStream;

import java.io.PrintStream;

import java.io.PrintWriter;

import java.io.Serializable;

import java.lang.Process;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.SocketAddress;

import java.net.SocketException;

import java.nio.file.Files;

import java.nio.channels.Channel;

import java.nio.channels.ServerSocketChannel;

import java.rmi.AccessException;

import java.rmi.AlreadyBoundException;

import java.rmi.ConnectException;

import java.rmi.ConnectIOException;

import java.rmi.MarshalledObject;

import java.rmi.NoSuchObjectException;

import java.rmi.NotBoundException;

import java.rmi.Remote;

import java.rmi.RemoteException;

import java.rmi.activation.ActivationDesc;

import java.rmi.activation.ActivationException;

import java.rmi.activation.ActivationGroupDesc;

import java.rmi.activation.ActivationGroup;

import java.rmi.activation.ActivationGroupID;

import java.rmi.activation.ActivationID;

import java.rmi.activation.ActivationInstantiator;

import java.rmi.activation.ActivationMonitor;

import java.rmi.activation.ActivationSystem;

import java.rmi.activation.Activator;

import java.rmi.activation.UnknownGroupException;

import java.rmi.activation.UnknownObjectException;

import java.rmi.registry.Registry;

import java.rmi.server.ObjID;

import java.rmi.server.RMIClassLoader;

import java.rmi.server.RMIClientSocketFactory;

import java.rmi.server.RMIServerSocketFactory;

import java.rmi.server.RemoteObject;

import java.rmi.server.RemoteServer;

import java.rmi.server.UnicastRemoteObject;

import java.security.AccessControlException;

import java.security.AccessController;

import java.security.AllPermission;

import java.security.CodeSource;

import java.security.Permission;

import java.security.PermissionCollection;

import java.security.Permissions;

import java.security.Policy;

import java.security.PrivilegedAction;

import java.security.PrivilegedExceptionAction;

import java.security.cert.Certificate;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.Properties;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.concurrent.ConcurrentHashMap;

import sun.rmi.log.LogHandler;

import sun.rmi.log.ReliableLog;

import sun.rmi.registry.RegistryImpl;

import sun.rmi.runtime.NewThreadAction;

import sun.rmi.transport.LiveRef;

import sun.security.action.GetBooleanAction;

import sun.security.action.GetIntegerAction;

import sun.security.action.GetPropertyAction;

import sun.security.provider.PolicyFile;

import com.sun.rmi.rmid.ExecPermission;

import com.sun.rmi.rmid.ExecOptionPermission;

/**

 * The Activator facilitates remote object activation. A "faulting"

 * remote reference calls the activator's <code>activate</code> method

 * to obtain a "live" reference to a activatable remote object. Upon

 * receiving a request for activation, the activator looks up the

 * activation descriptor for the activation identifier, id, determines

 * the group in which the object should be activated and invokes the

 * activate method on the object's activation group (described by the

 * remote interface <code>ActivationInstantiator</code>). The

 * activator initiates the execution of activation groups as

 * necessary. For example, if an activation group for a specific group

 * identifier is not already executing, the activator will spawn a

 * child process for the activation group. <p>

 *

 * The activator is responsible for monitoring and detecting when

 * activation groups fail so that it can remove stale remote references

 * from its internal tables. <p>

 *

 * @author      Ann Wollrath

 * @since       1.2

 */

public class Activation implements Serializable {

    /** indicate compatibility with JDK 1.2 version of class */

    private static final long serialVersionUID = 2921265612698155191L;

    private static final byte MAJOR_VERSION = 1;

    private static final byte MINOR_VERSION = 0;

    /** exec policy object */

    private static Object execPolicy;

    private static Method execPolicyMethod;

    private static boolean debugExec;

    /** maps activation id to its respective group id */

    private Map<ActivationID,ActivationGroupID> idTable =

        new ConcurrentHashMap<>();

    /** maps group id to its GroupEntry groups */

    private Map<ActivationGroupID,GroupEntry> groupTable =

        new ConcurrentHashMap<>();

    private byte majorVersion = MAJOR_VERSION;

    private byte minorVersion = MINOR_VERSION;

    /** number of simultaneous group exec's */

    private transient int groupSemaphore;

    /** counter for numbering groups */

    private transient int groupCounter;

    /** reliable log to hold descriptor table */

    private transient ReliableLog log;

    /** number of updates since last snapshot */

    private transient int numUpdates;

    /** the java command */

    // accessed by GroupEntry

    private transient String[] command;

    /** timeout on wait for child process to be created or destroyed */

    private static final long groupTimeout =

        getInt("sun.rmi.activation.groupTimeout", 60000);

    /** take snapshot after this many updates */

    private static final int snapshotInterval =

        getInt("sun.rmi.activation.snapshotInterval", 200);

    /** timeout on wait for child process to be created */

    private static final long execTimeout =

        getInt("sun.rmi.activation.execTimeout", 30000);

    private static final Object initLock = new Object();

    private static boolean initDone = false;

    // this should be a *private* method since it is privileged

    private static int getInt(String name, int def) {

        return AccessController.doPrivileged(new GetIntegerAction(name, def));

    }

    private transient Activator activator;

    private transient Activator activatorStub;

    private transient ActivationSystem system;

    private transient ActivationSystem systemStub;

    private transient ActivationMonitor monitor;

    private transient Registry registry;

    private transient volatile boolean shuttingDown = false;

    private transient volatile Object startupLock;

    private transient Thread shutdownHook;

    private static ResourceBundle resources = null;

    /**

     * Create an uninitialized instance of Activation that can be

     * populated with log data.  This is only called when the initial

     * snapshot is taken during the first incarnation of rmid.

     */

    private Activation() {}

    /**

     * Recover activation state from the reliable log and initialize

     * activation services.

     */

    private static void startActivation(int port,

                                        RMIServerSocketFactory ssf,

                                        String logName,

                                        String[] childArgs)

        throws Exception

    {

        ReliableLog log = new ReliableLog(logName, new ActLogHandler());

        Activation state = (Activation) log.recover();

        state.init(port, ssf, log, childArgs);

    }

    /**

     * Initialize the Activation instantiation; start activation

     * services.

     */

    private void init(int port,

                      RMIServerSocketFactory ssf,

                      ReliableLog log,

                      String[] childArgs)

        throws Exception

    {

        // initialize

        this.log = log;

        numUpdates = 0;

        shutdownHook =  new ShutdownHook();

        groupSemaphore = getInt("sun.rmi.activation.groupThrottle", 3);

        groupCounter = 0;

        Runtime.getRuntime().addShutdownHook(shutdownHook);

        // Use array size of 0, since the value from calling size()

        // may be out of date by the time toArray() is called.

        ActivationGroupID[] gids =

            groupTable.keySet().toArray(new ActivationGroupID[0]);

        synchronized (startupLock = new Object()) {

            // all the remote methods briefly synchronize on startupLock

            // (via checkShutdown) to make sure they don't happen in the

            // middle of this block.  This block must not cause any such

            // incoming remote calls to happen, or deadlock would result!

            activator = new ActivatorImpl(port, ssf);

            activatorStub = (Activator) RemoteObject.toStub(activator);

            system = new ActivationSystemImpl(port, ssf);

            systemStub = (ActivationSystem) RemoteObject.toStub(system);

            monitor = new ActivationMonitorImpl(port, ssf);

            initCommand(childArgs);

            registry = new SystemRegistryImpl(port, null, ssf, systemStub);

            if (ssf != null) {

                synchronized (initLock) {

                    initDone = true;

                    initLock.notifyAll();

                }

            }

        }

        startupLock = null;

        // restart services

        for (int i = gids.length; --i >= 0; ) {

            try {

                getGroupEntry(gids[i]).restartServices();

            } catch (UnknownGroupException e) {

                System.err.println(

                    getTextResource("rmid.restart.group.warning"));

                e.printStackTrace();

            }

        }

    }

    /**

     * Previous versions used HashMap instead of ConcurrentHashMap.

     * Replace any HashMaps found during deserialization with

     * ConcurrentHashMaps.

     */

    private void readObject(ObjectInputStream ois)

        throws IOException, ClassNotFoundException

    {

        ois.defaultReadObject();

        if (! (groupTable instanceof ConcurrentHashMap)) {

            groupTable = new ConcurrentHashMap<>(groupTable);

        }

        if (! (idTable instanceof ConcurrentHashMap)) {

            idTable = new ConcurrentHashMap<>(idTable);

        }

    }

    private static class SystemRegistryImpl extends RegistryImpl {

        private static final String NAME = ActivationSystem.class.getName();

        private static final long serialVersionUID = 4877330021609408794L;

        private final ActivationSystem systemStub;

        SystemRegistryImpl(int port,

                           RMIClientSocketFactory csf,

                           RMIServerSocketFactory ssf,

                           ActivationSystem systemStub)

            throws RemoteException

        {

            super(port, csf, ssf);

            this.systemStub = systemStub;

        }

        /**

         * Returns the activation system stub if the specified name

         * matches the activation system's class name, otherwise

         * returns the result of invoking super.lookup with the specified

         * name.

         */

        public Remote lookup(String name)

            throws RemoteException, NotBoundException

        {

            if (name.equals(NAME)) {

                return systemStub;

            } else {

                return super.lookup(name);

            }

        }

        public String[] list() throws RemoteException {

            String[] list1 = super.list();

            int length = list1.length;

            String[] list2 = new String[length + 1];

            if (length > 0) {

                System.arraycopy(list1, 0, list2, 0, length);

            }

            list2[length] = NAME;

            return list2;

        }

        public void bind(String name, Remote obj)

            throws RemoteException, AlreadyBoundException, AccessException

        {

            if (name.equals(NAME)) {

                throw new AccessException(

                    "binding ActivationSystem is disallowed");

            } else {

                RegistryImpl.checkAccess("ActivationSystem.bind");

                super.bind(name, obj);

            }

        }

        public void unbind(String name)

            throws RemoteException, NotBoundException, AccessException

        {

            if (name.equals(NAME)) {

                throw new AccessException(

                    "unbinding ActivationSystem is disallowed");

            } else {

                RegistryImpl.checkAccess("ActivationSystem.unbind");

                super.unbind(name);

            }

        }

        public void rebind(String name, Remote obj)

            throws RemoteException, AccessException

        {

            if (name.equals(NAME)) {

                throw new AccessException(

                    "binding ActivationSystem is disallowed");

            } else {

                RegistryImpl.checkAccess("ActivationSystem.rebind");

                super.rebind(name, obj);

            }

        }

    }

    class ActivatorImpl extends RemoteServer implements Activator {

        // Because ActivatorImpl has a fixed ObjID, it can be

        // called by clients holding stale remote references.  Each of

        // its remote methods, then, must check startupLock (calling

        // checkShutdown() is easiest).

        private static final long serialVersionUID = -3654244726254566136L;

        /**

         * Construct a new Activator on a specified port.

         */

        ActivatorImpl(int port, RMIServerSocketFactory ssf)

            throws RemoteException

        {

            /* Server ref must be created and assigned before remote object

             * 'this' can be exported.

             */

            LiveRef lref =

                new LiveRef(new ObjID(ObjID.ACTIVATOR_ID), port, null, ssf);

            UnicastServerRef uref = new UnicastServerRef(lref);

            ref = uref;

            uref.exportObject(this, null, false);

        }

        public MarshalledObject<? extends Remote> activate(ActivationID id,

                                                           boolean force)

            throws ActivationException, UnknownObjectException, RemoteException

        {

            checkShutdown();

            return getGroupEntry(id).activate(id, force);

        }

    }

    class ActivationMonitorImpl extends UnicastRemoteObject

        implements ActivationMonitor

    {

        private static final long serialVersionUID = -6214940464757948867L;

        ActivationMonitorImpl(int port, RMIServerSocketFactory ssf)

            throws RemoteException

        {

            super(port, null, ssf);

        }

        public void inactiveObject(ActivationID id)

            throws UnknownObjectException, RemoteException

        {

            try {

                checkShutdown();

            } catch (ActivationException e) {

                return;

            }

            RegistryImpl.checkAccess("Activator.inactiveObject");

            getGroupEntry(id).inactiveObject(id);

        }

        public void activeObject(ActivationID id,

                                 MarshalledObject<? extends Remote> mobj)

            throws UnknownObjectException, RemoteException

        {

            try {

                checkShutdown();

            } catch (ActivationException e) {

                return;

            }

            RegistryImpl.checkAccess("ActivationSystem.activeObject");

            getGroupEntry(id).activeObject(id, mobj);

        }

        public void inactiveGroup(ActivationGroupID id,

                                  long incarnation)

            throws UnknownGroupException, RemoteException

        {

            try {

                checkShutdown();

            } catch (ActivationException e) {

                return;

            }

            RegistryImpl.checkAccess("ActivationMonitor.inactiveGroup");

            getGroupEntry(id).inactiveGroup(incarnation, false);

        }

    }

    /**

     * SameHostOnlyServerRef checks that access is from a local client

     * before the parameters are deserialized.  The unmarshalCustomCallData

     * hook is used to check the network address of the caller

     * with RegistryImpl.checkAccess().

     * The kind of access is retained for an exception if one is thrown.

     */

    static class SameHostOnlyServerRef extends UnicastServerRef {

        private static final long serialVersionUID = 1234L;

        private String accessKind;      // an exception message

        /**

         * Construct a new SameHostOnlyServerRef from a LiveRef.

         * @param lref a LiveRef

         */

        SameHostOnlyServerRef(LiveRef lref, String accessKind) {

            super(lref);

            this.accessKind = accessKind;

        }

        @Override

        protected void unmarshalCustomCallData(ObjectInput in) throws IOException, ClassNotFoundException {

            RegistryImpl.checkAccess(accessKind);

            super.unmarshalCustomCallData(in);

        }

    }

    class ActivationSystemImpl

        extends RemoteServer

        implements ActivationSystem

    {

        private static final long serialVersionUID = 9100152600327688967L;

        // Because ActivationSystemImpl has a fixed ObjID, it can be

        // called by clients holding stale remote references.  Each of

        // its remote methods, then, must check startupLock (calling

        // checkShutdown() is easiest).

        ActivationSystemImpl(int port, RMIServerSocketFactory ssf)

            throws RemoteException

        {

            /* Server ref must be created and assigned before remote object

             * 'this' can be exported.

             */

            LiveRef lref = new LiveRef(new ObjID(4), port, null, ssf);

            UnicastServerRef uref = new SameHostOnlyServerRef(lref,

                    "ActivationSystem.nonLocalAccess");

            ref = uref;

            uref.exportObject(this, null);

        }

        public ActivationID registerObject(ActivationDesc desc)

            throws ActivationException, UnknownGroupException, RemoteException

        {

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            ActivationGroupID groupID = desc.getGroupID();

            ActivationID id = new ActivationID(activatorStub);

            getGroupEntry(groupID).registerObject(id, desc, true);

            return id;

        }

        public void unregisterObject(ActivationID id)

            throws ActivationException, UnknownObjectException, RemoteException

        {

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            getGroupEntry(id).unregisterObject(id, true);

        }

        public ActivationGroupID registerGroup(ActivationGroupDesc desc)

            throws ActivationException, RemoteException

        {

            Thread.dumpStack();

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            checkArgs(desc, null);

            ActivationGroupID id = new ActivationGroupID(systemStub);

            GroupEntry entry = new GroupEntry(id, desc);

            // table insertion must take place before log update

            groupTable.put(id, entry);

            addLogRecord(new LogRegisterGroup(id, desc));

            return id;

        }

        public ActivationMonitor activeGroup(ActivationGroupID id,

                                             ActivationInstantiator group,

                                             long incarnation)

            throws ActivationException, UnknownGroupException, RemoteException

        {

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            getGroupEntry(id).activeGroup(group, incarnation);

            return monitor;

        }

        public void unregisterGroup(ActivationGroupID id)

            throws ActivationException, UnknownGroupException, RemoteException

        {

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            // remove entry before unregister so state is updated before

            // logged

            removeGroupEntry(id).unregisterGroup(true);

        }

        public ActivationDesc setActivationDesc(ActivationID id,

                                                ActivationDesc desc)

            throws ActivationException, UnknownObjectException, RemoteException

        {

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            if (!getGroupID(id).equals(desc.getGroupID())) {

                throw new ActivationException(

                    "ActivationDesc contains wrong group");

            }

            return getGroupEntry(id).setActivationDesc(id, desc, true);

        }

        public ActivationGroupDesc setActivationGroupDesc(ActivationGroupID id,

                                                          ActivationGroupDesc desc)

            throws ActivationException, UnknownGroupException, RemoteException

        {

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            checkArgs(desc, null);

            return getGroupEntry(id).setActivationGroupDesc(id, desc, true);

        }

        public ActivationDesc getActivationDesc(ActivationID id)

            throws ActivationException, UnknownObjectException, RemoteException

        {

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            return getGroupEntry(id).getActivationDesc(id);

        }

        public ActivationGroupDesc getActivationGroupDesc(ActivationGroupID id)

            throws ActivationException, UnknownGroupException, RemoteException

        {

            checkShutdown();

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            return getGroupEntry(id).desc;

        }

        /**

         * Shutdown the activation system. Destroys all groups spawned by

         * the activation daemon and exits the activation daemon.

         */

        public void shutdown() throws AccessException {

            // RegistryImpl.checkAccess() is done in the SameHostOnlyServerRef

            // during unmarshallCustomData and is not applicable to local access.

            Object lock = startupLock;

            if (lock != null) {

                synchronized (lock) {

                    // nothing

                }

            }

            synchronized (Activation.this) {

                if (!shuttingDown) {

                    shuttingDown = true;

                    (new Shutdown()).start();

                }

            }

        }

    }

    private void checkShutdown() throws ActivationException {

        // if the startup critical section is running, wait until it

        // completes/fails before continuing with the remote call.

        Object lock = startupLock;

        if (lock != null) {

            synchronized (lock) {

                // nothing

            }

        }

        if (shuttingDown == true) {

            throw new ActivationException(

                "activation system shutting down");

        }

    }

    private static void unexport(Remote obj) {

        for (;;) {

            try {

                if (UnicastRemoteObject.unexportObject(obj, false) == true) {

                    break;

                } else {

                    Thread.sleep(100);

                }

            } catch (Exception e) {

                continue;

            }

        }

    }

    /**

     * Thread to shutdown rmid.

     */

    private class Shutdown extends Thread {

        Shutdown() {

            super("rmid Shutdown");

        }

        public void run() {

            try {

                /*

                 * Unexport activation system services

                 */

                unexport(activator);

                unexport(system);

                // destroy all child processes (groups)

                for (GroupEntry groupEntry : groupTable.values()) {

                    groupEntry.shutdown();

                }

                Runtime.getRuntime().removeShutdownHook(shutdownHook);

                /*

                 * Unexport monitor safely since all processes are destroyed.

                 */

                unexport(monitor);

                /*

                 * Close log file, fix for 4243264: rmid shutdown thread

                 * interferes with remote calls in progress.  Make sure

                 * the log file is only closed when it is impossible for

                 * its closure to interfere with any pending remote calls.

                 * We close the log when all objects in the rmid VM are

                 * unexported.

                 */

                try {

                    synchronized (log) {

                        log.close();

                    }

                } catch (IOException e) {

                }

            } finally {

                /*

                 * Now exit... A System.exit should only be done if

                 * the RMI activation system daemon was started up

                 * by the main method below (in which should always

                 * be the case since the Activation constructor is private).

                 */

                System.err.println(getTextResource("rmid.daemon.shutdown"));

                System.exit(0);

            }

        }

    }

    /** Thread to destroy children in the event of abnormal termination. */

    private class ShutdownHook extends Thread {

        ShutdownHook() {

            super("rmid ShutdownHook");

        }

        public void run() {

            synchronized (Activation.this) {

                shuttingDown = true;

            }

            // destroy all child processes (groups) quickly

            for (GroupEntry groupEntry : groupTable.values()) {

                groupEntry.shutdownFast();

            }

        }

    }

    /**

     * Returns the groupID for a given id of an object in the group.

     * Throws UnknownObjectException if the object is not registered.

     */

    private ActivationGroupID getGroupID(ActivationID id)

        throws UnknownObjectException

    {

        ActivationGroupID groupID = idTable.get(id);

        if (groupID != null) {

            return groupID;

        }

        throw new UnknownObjectException("unknown object: " + id);

    }

    /**

     * Returns the group entry for the group id, optionally removing it.

     * Throws UnknownGroupException if the group is not registered.

     */

    private GroupEntry getGroupEntry(ActivationGroupID id, boolean rm)

        throws UnknownGroupException

    {

        if (id.getClass() == ActivationGroupID.class) {

            GroupEntry entry;

            if (rm) {

                entry = groupTable.remove(id);

            } else {

                entry = groupTable.get(id);

            }

            if (entry != null && !entry.removed) {

                return entry;

            }

        }

        throw new UnknownGroupException("group unknown");

    }

    /**

     * Returns the group entry for the group id. Throws

     * UnknownGroupException if the group is not registered.

     */

    private GroupEntry getGroupEntry(ActivationGroupID id)

        throws UnknownGroupException

    {

        return getGroupEntry(id, false);

    }

    /**

     * Removes and returns the group entry for the group id. Throws

     * UnknownGroupException if the group is not registered.

     */

    private GroupEntry removeGroupEntry(ActivationGroupID id)

        throws UnknownGroupException

    {

        return getGroupEntry(id, true);

    }

    /**

     * Returns the group entry for the object's id. Throws

     * UnknownObjectException if the object is not registered or the

     * object's group is not registered.

     */

    private GroupEntry getGroupEntry(ActivationID id)

        throws UnknownObjectException

    {

        ActivationGroupID gid = getGroupID(id);

        GroupEntry entry = groupTable.get(gid);

        if (entry != null && !entry.removed) {

            return entry;

        }

        throw new UnknownObjectException("object's group removed");

    }

    /**

     * Container for group information: group's descriptor, group's

     * instantiator, flag to indicate pending group creation, and

     * table of the objects that are activated in the group.

     *

     * WARNING: GroupEntry objects should not be written into log file

     * updates.  GroupEntrys are inner classes of Activation and they

     * can not be serialized independent of this class.  If the

     * complete Activation system is written out as a log update, the

     * point of having updates is nullified.

     */

    private class GroupEntry implements Serializable {

        /** indicate compatibility with JDK 1.2 version of class */

        private static final long serialVersionUID = 7222464070032993304L;

        private static final int MAX_TRIES = 2;

        private static final int NORMAL = 0;

        private static final int CREATING = 1;

        private static final int TERMINATE = 2;

        private static final int TERMINATING = 3;

        ActivationGroupDesc desc = null;

        ActivationGroupID groupID = null;

        long incarnation = 0;

        Map<ActivationID,ObjectEntry> objects = new HashMap<>();

        Set<ActivationID> restartSet = new HashSet<>();

        transient ActivationInstantiator group = null;

        transient int status = NORMAL;

        transient long waitTime = 0;

        transient String groupName = null;

        transient Process child = null;

        transient boolean removed = false;

        transient Watchdog watchdog = null;

        GroupEntry(ActivationGroupID groupID, ActivationGroupDesc desc) {

            this.groupID = groupID;

            this.desc = desc;

        }

        void restartServices() {

            Iterator<ActivationID> iter = null;

            synchronized (this) {

                if (restartSet.isEmpty()) {

                    return;

                }

                /*

                 * Clone the restartSet so the set does not have to be locked

                 * during iteration. Locking the restartSet could cause

                 * deadlock if an object we are restarting caused another

                 * object in this group to be activated.

                 */

                iter = (new HashSet<ActivationID>(restartSet)).iterator();

            }

            while (iter.hasNext()) {

                ActivationID id = iter.next();

                try {

                    activate(id, true);

                } catch (Exception e) {

                    if (shuttingDown) {

                        return;

                    }

                    System.err.println(

                        getTextResource("rmid.restart.service.warning"));

                    e.printStackTrace();

                }

            }

        }

        synchronized void activeGroup(ActivationInstantiator inst,

                                      long instIncarnation)

            throws ActivationException, UnknownGroupException

        {

            if (incarnation != instIncarnation) {

                throw new ActivationException("invalid incarnation");

            }

            if (group != null) {

                if (group.equals(inst)) {

                    return;

                } else {

                    throw new ActivationException("group already active");

                }

            }

            if (child != null && status != CREATING) {

                throw new ActivationException("group not being created");

            }

            group = inst;

            status = NORMAL;

            notifyAll();

        }

        private void checkRemoved() throws UnknownGroupException {

            if (removed) {

                throw new UnknownGroupException("group removed");

            }

        }

        private ObjectEntry getObjectEntry(ActivationID id)

            throws UnknownObjectException

        {

            if (removed) {

                throw new UnknownObjectException("object's group removed");

            }

            ObjectEntry objEntry = objects.get(id);

            if (objEntry == null) {

                throw new UnknownObjectException("object unknown");

            }

            return objEntry;

        }

        synchronized void registerObject(ActivationID id,

                                         ActivationDesc desc,

                                         boolean addRecord)

            throws UnknownGroupException, ActivationException

        {

            checkRemoved();

            objects.put(id, new ObjectEntry(desc));

            if (desc.getRestartMode() == true) {

                restartSet.add(id);

            }

            // table insertion must take place before log update

            idTable.put(id, groupID);

            if (addRecord) {

                addLogRecord(new LogRegisterObject(id, desc));

            }

        }

        synchronized void unregisterObject(ActivationID id, boolean addRecord)

            throws UnknownGroupException, ActivationException

        {

            ObjectEntry objEntry = getObjectEntry(id);

            objEntry.removed = true;

            objects.remove(id);

            if (objEntry.desc.getRestartMode() == true) {

                restartSet.remove(id);

            }

            // table removal must take place before log update

            idTable.remove(id);

            if (addRecord) {

                addLogRecord(new LogUnregisterObject(id));

            }

        }

        synchronized void unregisterGroup(boolean addRecord)

           throws UnknownGroupException, ActivationException

        {

            checkRemoved();

            removed = true;

            for (Map.Entry<ActivationID,ObjectEntry> entry :

                     objects.entrySet())

            {

                ActivationID id = entry.getKey();

                idTable.remove(id);

                ObjectEntry objEntry = entry.getValue();

                objEntry.removed = true;

            }

            objects.clear();

            restartSet.clear();

            reset();

            childGone();

            // removal should be recorded before log update

            if (addRecord) {

                addLogRecord(new LogUnregisterGroup(groupID));

            }

        }

        synchronized ActivationDesc setActivationDesc(ActivationID id,

                                                      ActivationDesc desc,

                                                      boolean addRecord)

            throws UnknownObjectException, UnknownGroupException,

                   ActivationException

        {

            ObjectEntry objEntry = getObjectEntry(id);

            ActivationDesc oldDesc = objEntry.desc;

            objEntry.desc = desc;

            if (desc.getRestartMode() == true) {

                restartSet.add(id);

            } else {

                restartSet.remove(id);

            }

            // restart information should be recorded before log update

            if (addRecord) {

                addLogRecord(new LogUpdateDesc(id, desc));

            }

            return oldDesc;

        }

        synchronized ActivationDesc getActivationDesc(ActivationID id)

            throws UnknownObjectException, UnknownGroupException

        {

            return getObjectEntry(id).desc;

        }

        synchronized ActivationGroupDesc setActivationGroupDesc(

                ActivationGroupID id,

                ActivationGroupDesc desc,

                boolean addRecord)

            throws UnknownGroupException, ActivationException

        {

            checkRemoved();

            ActivationGroupDesc oldDesc = this.desc;

            this.desc = desc;

            // state update should occur before log update

            if (addRecord) {

                addLogRecord(new LogUpdateGroupDesc(id, desc));

            }

            return oldDesc;

        }

        synchronized void inactiveGroup(long incarnation, boolean failure)

            throws UnknownGroupException

        {

            checkRemoved();

            if (this.incarnation != incarnation) {

                throw new UnknownGroupException("invalid incarnation");

            }

            reset();

            if (failure) {

                terminate();

            } else if (child != null && status == NORMAL) {

                status = TERMINATE;

                watchdog.noRestart();

            }

        }

        synchronized void activeObject(ActivationID id,

                                       MarshalledObject<? extends Remote> mobj)

                throws UnknownObjectException

        {

            getObjectEntry(id).stub = mobj;

        }

        synchronized void inactiveObject(ActivationID id)

            throws UnknownObjectException

        {

            getObjectEntry(id).reset();

        }

        private synchronized void reset() {

            group = null;

            for (ObjectEntry objectEntry : objects.values()) {

                objectEntry.reset();

            }

        }

        private void childGone() {

            if (child != null) {

                child = null;

                watchdog.dispose();

                watchdog = null;

                status = NORMAL;

                notifyAll();

            }

        }

        private void terminate() {

            if (child != null && status != TERMINATING) {

                child.destroy();

                status = TERMINATING;

                waitTime = System.currentTimeMillis() + groupTimeout;

                notifyAll();

            }

        }

       /*

        * Fallthrough from TERMINATE to TERMINATING

        * is intentional

        */

        @SuppressWarnings("fallthrough")

        private void await() {

            while (true) {

                switch (status) {

                case NORMAL:

                    return;

                case TERMINATE:

                    terminate();

                case TERMINATING:

                    try {

                        child.exitValue();

                    } catch (IllegalThreadStateException e) {

                        long now = System.currentTimeMillis();

                        if (waitTime > now) {

                            try {

                                wait(waitTime - now);

                            } catch (InterruptedException ee) {

                            }

                            continue;

                        }

                        // REMIND: print message that group did not terminate?

                    }

                    childGone();

                    return;

                case CREATING:

                    try {

                        wait();

                    } catch (InterruptedException e) {

                    }

                }

            }

        }

        // no synchronization to avoid delay wrt getInstantiator

        void shutdownFast() {

            Process p = child;

            if (p != null) {

                p.destroy();

            }

        }

        synchronized void shutdown() {

            reset();

            terminate();

            await();

        }

        MarshalledObject<? extends Remote> activate(ActivationID id,

                                                    boolean force)

            throws ActivationException

        {

            Exception detail = null;

            /*

             * Attempt to activate object and reattempt (several times)

             * if activation fails due to communication problems.

             */

            for (int tries = MAX_TRIES; tries > 0; tries--) {

                ActivationInstantiator inst;

                long currentIncarnation;

                // look up object to activate

                ObjectEntry objEntry;

                synchronized (this) {

                    objEntry = getObjectEntry(id);

                    // if not forcing activation, return cached stub

                    if (!force && objEntry.stub != null) {

                        return objEntry.stub;

                    }

                    inst = getInstantiator(groupID);

                    currentIncarnation = incarnation;

                }

                boolean groupInactive = false;

                boolean failure = false;

                // activate object

                try {

                    return objEntry.activate(id, force, inst);

                } catch (NoSuchObjectException e) {

                    groupInactive = true;

                    detail = e;

                } catch (ConnectException e) {

                    groupInactive = true;

                    failure = true;

                    detail = e;

                } catch (ConnectIOException e) {

                    groupInactive = true;

                    failure = true;

                    detail = e;

                } catch (InactiveGroupException e) {

                    groupInactive = true;

                    detail = e;

                } catch (RemoteException e) {

                    // REMIND: wait some here before continuing?

                    if (detail == null) {

                        detail = e;

                    }

                }

                if (groupInactive) {

                    // group has failed or is inactive; mark inactive

                    try {

                        System.err.println(

                            MessageFormat.format(

                                getTextResource("rmid.group.inactive"),

                                detail.toString()));

                        detail.printStackTrace();

                        getGroupEntry(groupID).

                            inactiveGroup(currentIncarnation, failure);

                    } catch (UnknownGroupException e) {

                        // not a problem

                    }

                }

            }

            /**

             * signal that group activation failed, nested exception

             * specifies what exception occurred when the group did not

             * activate

             */

            throw new ActivationException("object activation failed after " +

                                          MAX_TRIES + " tries", detail);

        }

        /**

         * Returns the instantiator for the group specified by id and

         * entry. If the group is currently inactive, exec some

         * bootstrap code to create the group.

         */

        private ActivationInstantiator getInstantiator(ActivationGroupID id)

            throws ActivationException

        {

            assert Thread.holdsLock(this);

            await();

            if (group != null) {

                return group;

            }

            checkRemoved();

            boolean acquired = false;

            try {

                groupName = Pstartgroup();

                acquired = true;

                String[] argv = activationArgs(desc);

                checkArgs(desc, argv);

                if (debugExec) {

                    StringBuffer sb = new StringBuffer(argv[0]);

                    int j;

                    for (j = 1; j < argv.length; j++) {

                        sb.append(' ');

                        sb.append(argv[j]);

                    }

                    System.err.println(

                        MessageFormat.format(

                            getTextResource("rmid.exec.command"),

                            sb.toString()));

                }

                try {

                    child = Runtime.getRuntime().exec(argv);

                    status = CREATING;

                    ++incarnation;

                    watchdog = new Watchdog();

                    watchdog.start();

                    addLogRecord(new LogGroupIncarnation(id, incarnation));

                    // handle child I/O streams before writing to child

                    PipeWriter.plugTogetherPair

                        (child.getInputStream(), System.out,

                         child.getErrorStream(), System.err);

                    try (MarshalOutputStream out =

                            new MarshalOutputStream(child.getOutputStream())) {

                        out.writeObject(id);

                        out.writeObject(desc);

                        out.writeLong(incarnation);

                        out.flush();

                    }

                } catch (IOException e) {

                    terminate();

                    throw new ActivationException(

                        "unable to create activation group", e);

                }

                try {

                    long now = System.currentTimeMillis();

                    long stop = now + execTimeout;

                    do {

                        wait(stop - now);

                        if (group != null) {

                            return group;

                        }

                        now = System.currentTimeMillis();

                    } while (status == CREATING && now < stop);

                } catch (InterruptedException e) {

                }

                terminate();

                throw new ActivationException(

                        (removed ?

                         "activation group unregistered" :

                         "timeout creating child process"));

            } finally {

                if (acquired) {

                    Vstartgroup();

                }

            }

        }

        /**

         * Waits for process termination and then restarts services.

         */

        private class Watchdog extends Thread {

            private final Process groupProcess = child;

            private final long groupIncarnation = incarnation;

            private boolean canInterrupt = true;

            private boolean shouldQuit = false;

            private boolean shouldRestart = true;

            Watchdog() {

                super("WatchDog-"  + groupName + "-" + incarnation);

                setDaemon(true);

            }

            public void run() {

                if (shouldQuit) {

                    return;

                }

                /*

                 * Wait for the group to crash or exit.

                 */

                try {

                    groupProcess.waitFor();

                } catch (InterruptedException exit) {

                    return;

                }

                boolean restart = false;

                synchronized (GroupEntry.this) {

                    if (shouldQuit) {

                        return;

                    }

                    canInterrupt = false;

                    interrupted(); // clear interrupt bit

                    /*

                     * Since the group crashed, we should

                     * reset the entry before activating objects

                     */

                    if (groupIncarnation == incarnation) {

                        restart = shouldRestart && !shuttingDown;

                        reset();

                        childGone();

                    }

                }