1 files changed, 375 insertions, 0 deletions
diff --git a/gcc-4.4.3/libjava/classpath/gnu/CORBA/OrbFocused.java b/gcc-4.4.3/libjava/classpath/gnu/CORBA/OrbFocused.java
new file mode 100644
index 000000000..572acbc11
--- /dev/null
+++ b/gcc-4.4.3/libjava/classpath/gnu/CORBA/OrbFocused.java
@@ -0,0 +1,375 @@
+/* OrbFocused.java --
+   Copyright (C) 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.CORBA;
+
+import gnu.CORBA.Poa.ORB_1_4;
+
+import org.omg.CORBA.BAD_INV_ORDER;
+import org.omg.CORBA.BAD_OPERATION;
+import org.omg.CORBA.BAD_PARAM;
+import org.omg.CORBA.CompletionStatus;
+import org.omg.CORBA.NO_RESOURCES;
+import org.omg.CORBA.portable.InvokeHandler;
+
+import java.applet.Applet;
+import java.net.ServerSocket;
+import java.util.Iterator;
+import java.util.Properties;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+/**
+ * This class implements the ORB that uses a single port or the restricted port
+ * range for all its objects. It is required to for use together with various
+ * firewalls that does not allow opening multiple randomly selected ports, as
+ * the defauld CORBA implementation used to do. The firewal must be configured
+ * to allow CORBA to work on one fixed port or (for better performance) on a
+ * small fixed range of ports. This does not restrict the maximal number of the
+ * connected objects as the objects can share the same port.
+ * 
+ * The used port or the used port range can be specified via property
+ * gnu.CORBA.ListenerPort. The value of this property is a single port or range
+ * of ports, boundary values (inclusive) being separeted by dash (for instance,
+ * "1245-1250").
+ * 
+ * It is possible to instantiate multiple instances of the focused ORBs and
+ * combine them with the ordinary ORBs. If you instantiate several instances of
+ * the focused ORBs on the same host, they used port sets should not overlap.
+ * 
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class OrbFocused
+  extends ORB_1_4
+{
+  /**
+   * The name of the fixed port range property. The presence of this property
+   * indicates that the default focused ORB must be used.
+   */
+  public static final String LISTENER_PORT = "gnu.CORBA.ListenerPort";
+
+  /**
+   * The start of the range of the available ports, inclusive.
+   */
+  int m_ports_from = -1;
+
+  /**
+   * The end of the range of the available ports, inclusive.
+   */
+  int m_ports_to = -1;
+
+  /**
+   * The requests to port are served in parallel threads.
+   */
+  static final int PARALLEL = 0;
+
+  /**
+   * The requests to port are served in the same thread.
+   */
+  static final int SEQUENTIAL = 1;
+
+  /**
+   * The random number generator to get a random port in the valid range.
+   */
+  Random m_random = new Random();
+
+  /**
+   * Parse the "gnu.CORBA.ListenerPort" property and initialize the valid port
+   * set range.
+   */
+  public void setPortRange(String property)
+  {
+    int from, to;
+    try
+      {
+        StringTokenizer st = new StringTokenizer(property, " -");
+        if (st.countTokens() == 1)
+          from = to = Integer.parseInt(st.nextToken());
+        else
+          {
+            from = Integer.parseInt(st.nextToken());
+            to = Integer.parseInt(st.nextToken());
+            m_random = new Random();
+          }
+        setPortRange(from, to);
+      }
+    catch (Exception ex)
+      {
+        throw new BAD_PARAM("Unable to parse port range '" + property + "'");
+      }
+  }
+
+  /**
+   * Set the port range.
+   * 
+   * @param from - start of the port range, inclusive.
+   * @param to - end of the port range, inclusive.
+   */
+  public void setPortRange(int from, int to)
+  {
+    if (from < 0 || to < 0 || to < from)
+      throw new BAD_PARAM("Invalid range");
+    m_ports_from = from;
+    m_ports_to = to;
+  }
+
+  /**
+   * Get the port from the previously specified usage range.
+   */
+  int getPortFromRange(int attempt)
+  {
+    if (m_ports_from == m_ports_to)
+      return m_ports_from;
+    else if (m_ports_to - m_ports_from < RANDOM_PORT_ATTEMPTS)
+      return m_ports_from + (attempt % (m_ports_to - m_ports_from + 1));
+    else
+      return m_random.nextInt(m_ports_to - m_ports_from + 1) + m_ports_from;
+  }
+
+  /**
+   * Get the shared port server where the new object can be added. This may
+   * result reusing the existing server or instantiating a new server. If the
+   * new server is instantiated and the ORB is already running, the server is
+   * started.
+   */
+  protected portServer getPortServer(int type)
+  {
+    portServer p;
+
+    int n;
+    if (m_ports_from < m_ports_to)
+      n = RANDOM_PORT_ATTEMPTS;
+    else
+      n = 1;
+
+    Ports: for (int a = 0; a < n; a++)
+      {
+        int port = getPortFromRange(a);
+        for (int i = 0; i < portServers.size(); i++)
+          {
+            p = (portServer) portServers.get(i);
+            if (p.s_port == port)
+              {
+                return p;
+              }
+          }
+        // The server is not yet instantiated. Instantiate.
+        try
+          {
+            // Check if the port is ok:
+            ServerSocket s = socketFactory.createServerSocket(port);
+            s.close();
+
+            portServer shared;
+
+            switch (type)
+              {
+                case PARALLEL:
+                  shared = new portServer(port);
+                  break;
+
+                case SEQUENTIAL:
+                  shared = new sharedPortServer(port);
+                  break;
+
+                default:
+                  throw new InternalError("Invalid server type " + type);
+              }
+
+            portServers.add(shared);
+
+            if (running)
+              shared.start();
+
+            return shared;
+          }
+        catch (Exception ex)
+          {
+            // Port is taken or probably other problems.
+            continue Ports;
+          }
+      }
+    throw new NO_RESOURCES("No free port available at " + m_ports_from + "-"
+      + m_ports_to, Minor.Ports, CompletionStatus.COMPLETED_NO);
+  }
+
+  /**
+   * Start the ORBs main working cycle (receive invocation - invoke on the local
+   * object - send response - wait for another invocation).
+   * 
+   * The method only returns after calling {@link #shutdown(boolean)}.
+   */
+  public void run()
+  {
+    if (m_ports_from < 0 || m_ports_to < 0)
+      throw new BAD_INV_ORDER("For " + getClass().getName() + " "
+        + LISTENER_PORT + " property must be set");
+
+    running = true;
+
+    // Start all port servers. In the current subclass, the portServers
+    // collection must be already filled in.
+    Iterator iter = portServers.iterator();
+
+    while (iter.hasNext())
+      {
+        portServer subserver = (portServer) iter.next();
+
+        if (!subserver.isAlive())
+          {
+            // Reuse the current thread for the last portServer.
+            if (!iter.hasNext())
+              {
+                // Discard the iterator.
+                iter = null;
+                subserver.run();
+                return;
+              }
+            else
+              subserver.start();
+          }
+      }
+  }
+
+  /**
+   * Get free port from the allowed range. This method instantiates the port
+   * server for the returned port.
+   */
+  public int getFreePort()
+    throws BAD_OPERATION
+  {
+    portServer s = getPortServer(PARALLEL);
+    return s.s_port;
+  }
+
+  /**
+   * Connect the given CORBA object to this ORB, explicitly specifying the
+   * object key and the identity of the thread (and port), where the object must
+   * be served. The identity is normally the POA.
+   * 
+   * The new port server will be started only if there is no one already running
+   * for the same identity. Otherwise, the task of the existing port server will
+   * be widened, including duty to serve the given object. All objects,
+   * connected to a single identity by this method, will process they requests
+   * subsequently in the same thread. The method is used when the expected
+   * number of the objects is too large to have a single port and thread per
+   * object. This method is used by POAs, having a single thread policy.
+   * 
+   * @param object the object, must implement the {@link InvokeHandler})
+   * interface.
+   * @param key the object key, usually used to identify the object from remote
+   * side.
+   * @param port the port, where the object must be connected.
+   * 
+   * @throws BAD_PARAM if the object does not implement the
+   * {@link InvokeHandler}).
+   */
+  public void connect_1_thread(org.omg.CORBA.Object object, byte[] key,
+    java.lang.Object identity)
+  {
+    sharedPortServer shared = (sharedPortServer) identities.get(identity);
+    if (shared == null)
+      {
+        shared = (sharedPortServer) getPortServer(SEQUENTIAL);
+        identities.put(identity, shared);
+        if (running)
+          {
+            shared.start();
+          }
+      }
+
+    Connected_objects.cObject ref = connected_objects.add(key, object,
+      shared.s_port, identity);
+    IOR ior = createIOR(ref);
+    prepareObject(object, ior);
+  }
+
+  /**
+   * In this type of ORB, the service is started by {@link #getPortServer}. The
+   * method below is not in use and should return without action.
+   */
+  public void startService(IOR ior)
+  {
+  }
+
+  /**
+   * Set parameters (additionally search for the port range property).
+   */
+  protected void set_parameters(Applet applet, Properties props)
+  {
+    super.set_parameters(applet, props);
+    String lp = applet.getParameter(LISTENER_PORT);
+    if (lp != null)
+      setPortRange(lp);
+  }
+
+  /**
+   * Set parameters (additionally search for the port range property).
+   */
+  protected void set_parameters(String[] args, Properties props)
+  {
+    super.set_parameters(args, props);
+    String lp = null;
+
+    String lpKey = "-" + LISTENER_PORT;
+
+    if (args != null)
+      if (args.length >= 2)
+        {
+          for (int i = 0; i < args.length - 1; i++)
+            if (args[i].equals(lpKey))
+              lp = args[i + 1];
+        }
+
+    if (lp != null)
+      setPortRange(lp);
+
+  }
+
+  /**
+   * Additionally set the port range property, when applicable.
+   */
+  protected void useProperties(Properties props)
+  {
+    super.useProperties(props);
+    String lp = props.getProperty(LISTENER_PORT);
+    if (lp != null)
+      setPortRange(lp);
+  }
+
+}