obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1423 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/CORBA/gnuRequest.java b/libjava/classpath/gnu/CORBA/gnuRequest.java
new file mode 100644
index 000000000..56c9dbb1f
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/gnuRequest.java
@@ -0,0 +1,1423 @@
+/* gnuRequest.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.CDR.BufferredCdrInput;
+import gnu.CORBA.CDR.BufferedCdrOutput;
+import gnu.CORBA.GIOP.MessageHeader;
+import gnu.CORBA.GIOP.ReplyHeader;
+import gnu.CORBA.GIOP.RequestHeader;
+import gnu.CORBA.GIOP.CodeSetServiceContext;
+import gnu.CORBA.Interceptor.gnuClientRequestInfo;
+import gnu.CORBA.Poa.ORB_1_4;
+
+import org.omg.CORBA.ARG_IN;
+import org.omg.CORBA.ARG_INOUT;
+import org.omg.CORBA.ARG_OUT;
+import org.omg.CORBA.Any;
+import org.omg.CORBA.BAD_INV_ORDER;
+import org.omg.CORBA.BAD_PARAM;
+import org.omg.CORBA.Bounds;
+import org.omg.CORBA.COMM_FAILURE;
+import org.omg.CORBA.CompletionStatus;
+import org.omg.CORBA.Context;
+import org.omg.CORBA.ContextList;
+import org.omg.CORBA.Environment;
+import org.omg.CORBA.ExceptionList;
+import org.omg.CORBA.INV_POLICY;
+import org.omg.CORBA.MARSHAL;
+import org.omg.CORBA.NO_IMPLEMENT;
+import org.omg.CORBA.NO_RESOURCES;
+import org.omg.CORBA.NVList;
+import org.omg.CORBA.NamedValue;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.Policy;
+import org.omg.CORBA.Request;
+import org.omg.CORBA.SystemException;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.UnknownUserException;
+import org.omg.CORBA.portable.ObjectImpl;
+import org.omg.IOP.ServiceContext;
+import org.omg.IOP.TAG_CODE_SETS;
+import org.omg.IOP.TAG_INTERNET_IOP;
+import org.omg.IOP.TaggedComponent;
+import org.omg.IOP.TaggedProfile;
+import org.omg.PortableInterceptor.ClientRequestInfo;
+import org.omg.PortableInterceptor.ClientRequestInterceptorOperations;
+import org.omg.PortableInterceptor.ForwardRequest;
+import org.omg.PortableInterceptor.InvalidSlot;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import java.net.Socket;
+
+import java.util.ArrayList;
+
+/**
+ * The implementation of the CORBA request.
+ *
+ * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
+ */
+public class gnuRequest extends Request implements Cloneable
+{
+  /**
+   * The maximal supported GIOP version.
+   */
+  public static Version MAX_SUPPORTED = new Version(1, 2);
+
+  /**
+   * The initial pause that the Request makes when the required port is not
+   * available.
+   */
+  public static int PAUSE_INITIAL = 50;
+
+  /**
+   * The number of repretetive attempts to get a required port, if it is not
+   * immediately available.
+   */
+  public static int PAUSE_STEPS = 12;
+
+  /**
+   * The maximal pausing interval between two repetetive attempts. The interval
+   * doubles after each unsuccessful attempt, but will not exceed this value.
+   */
+  public static int PAUSE_MAX = 1000;
+
+  /**
+   * The interceptor, listening the major request submission points.
+   */
+  ClientRequestInterceptorOperations m_interceptor;
+
+  /**
+   * The request info, used by interceptor.
+   */
+  ClientRequestInfo m_info = new gnuClientRequestInfo(this);
+
+  /**
+   * The empty byte array.
+   */
+  private static final RawReply EMPTY =
+    new RawReply(null, new MessageHeader(), new byte[ 0 ]);
+
+  /**
+   * The context holder for methods ctx(Context) and ctx().
+   */
+  protected Context m_context;
+
+  /**
+   * The context list for method contexts().
+   */
+  protected ContextList m_context_list;
+
+  /**
+   * The request environment for holding the exception the has possibly been
+   * thrown by the method being invoked.
+   */
+  protected Environment m_environment = new gnuEnvironment();
+
+  /**
+   * The list of all exceptions that can be thrown by the method being invoked.
+   */
+  protected ExceptionList m_exceptions = new gnuExceptionList();
+
+  /**
+   * The result, returned by the invoked method (function).
+   */
+  protected NamedValue m_result = new gnuNamedValue();
+
+  /**
+   * The exception id, received from the server, null if none.
+   */
+  protected String m_exception_id;
+
+  /**
+   * The thrown system exception.
+   */
+  protected SystemException m_sys_ex;
+
+  /**
+   * The invocation target.
+   */
+  protected org.omg.CORBA.Object m_target;
+
+  /**
+   * The name of the method being invoked.
+   */
+  protected String m_operation;
+
+  /**
+   * This field temporary remembers the value of the forwarded ior reference. If
+   * it is not null, the request was forwarded and the effective target is not
+   * the same as the default target.
+   */
+  public IOR m_forward_ior;
+
+  /**
+   * Is set when object, and not IOR is directly available.
+   */
+  public org.omg.CORBA.Object m_forwarding_target;
+
+  /**
+   * The flag, indicating that the request has been sent and the result is
+   * already received.
+   */
+  protected boolean complete;
+
+  /**
+   * The flag, indicating that the response to this request must be ignored
+   * (used with {@link #send_oneway()}).
+   */
+  protected boolean oneWay;
+
+  /**
+   * The flag, indicating that the request has been sent and no result is yet
+   * received.
+   */
+  protected boolean running;
+
+  /**
+   * The request arguments.
+   */
+  protected gnuNVList m_args = new gnuNVList();
+
+  /**
+   * The request arguments in the case when they are directly written into the
+   * parameter buffer.
+   */
+  protected StreamBasedRequest m_parameter_buffer;
+
+  /**
+   * The array of slots.
+   */
+  protected Any[] m_slots;
+
+  /**
+   * The request header currently in use.
+   */
+  protected RequestHeader m_rqh;
+
+  /**
+   * The reply header currently in use.
+   */
+  protected ReplyHeader m_rph;
+
+  /**
+   * The IOR of the target.
+   */
+  private IOR ior;
+
+  /**
+   * The ORB of the target.
+   */
+  private ORB orb;
+
+  /**
+   * The encoding, used to send the message.
+   *
+   * The default encoding is inherited from the set IOR (that string reference
+   * can be encoded in either Big or Little endian). If the IOR encoding is not
+   * known (for example, by obtaining the reference from the naming service),
+   * the Big Endian is used.
+   */
+  private boolean Big_endian = true;
+
+  /**
+   * Set the IOR data, sufficient to find the invocation target. This also sets
+   * default endian encoding for invocations.
+   *
+   * @see IOR.parse(String)
+   */
+  public void setIor(IOR an_ior)
+  {
+    ior = an_ior;
+    setBigEndian(ior.Big_Endian);
+  }
+
+  /**
+   * Used when redirecting request to another target.
+   */
+  gnuRequest redirected;
+
+  /**
+   * Get the IOR data, sufficient to find the invocation target.
+   *
+   * @return the IOR data.
+   */
+  public IOR getIor()
+  {
+    return ior;
+  }
+
+  /**
+   * Set the ORB, related to the invocation target.
+   */
+  public void setORB(ORB an_orb)
+  {
+    orb = an_orb;
+
+    // Take the interceptor from the ORB.
+    if (orb instanceof OrbRestricted)
+      m_interceptor = ((OrbRestricted) orb).iClient;
+
+    if (m_interceptor != null && orb instanceof ORB_1_4)
+      {
+        m_slots = ((ORB_1_4) orb).ic_current.clone_slots();
+      }
+  }
+
+  /**
+   * Set the encoding that will be used to send the message. The default
+   * encoding is inherited from the set IOR (that string reference can be
+   * encoded in either Big or Little endian). If the IOR encoding is not known
+   * (for example, by obtaining the reference from the naming service), the Big
+   * Endian is used.
+   *
+   * @param use_big_endian true to use the Big Endian, false to use the Little
+   * Endian encoding.
+   */
+  public void setBigEndian(boolean use_big_endian)
+  {
+    Big_endian = use_big_endian;
+  }
+
+  /**
+   * The the method name to invoke.
+   *
+   * @param operation the method name.
+   */
+  public void setOperation(String operation)
+  {
+    m_operation = operation;
+  }
+
+  /**
+   * Get the parameter stream, where the invocation arguments should be written
+   * if they are written into the stream directly.
+   */
+  public StreamBasedRequest getParameterStream()
+  {
+    m_parameter_buffer = new StreamBasedRequest();
+    m_parameter_buffer.request = this;
+    m_parameter_buffer.setVersion(ior.Internet.version);
+    m_parameter_buffer.setCodeSet(CodeSetServiceContext.negotiate(ior.Internet.CodeSets));
+    m_parameter_buffer.setOrb(orb);
+    m_parameter_buffer.setBigEndian(Big_endian);
+
+    // For the old iiop versions, it is important to set the size
+    // correctly.
+    if (ior.Internet.version.until_inclusive(1, 1))
+      {
+        BufferedCdrOutput measure = new BufferedCdrOutput();
+        measure.setOffset(12);
+        if (m_rqh == null)
+          m_rqh = new gnu.CORBA.GIOP.v1_0.RequestHeader();
+        m_rqh.operation = m_operation;
+        m_rqh.object_key = ior.key;
+        m_rqh.write(measure);
+        m_parameter_buffer.setOffset(12 + measure.buffer.size());
+      }
+
+    return m_parameter_buffer;
+  }
+
+  /**
+   * Creates a shallow copy of this request.
+   */
+  public gnuRequest Clone()
+  {
+    try
+      {
+        return (gnuRequest) clone();
+      }
+    catch (CloneNotSupportedException ex)
+      {
+        throw new Unexpected(ex);
+      }
+  }
+
+  /** {@inheritDoc} */
+  public Any add_in_arg()
+  {
+    gnuNamedValue v = new gnuNamedValue();
+    v.setFlags(ARG_IN.value);
+    m_args.add(v);
+    return v.value();
+  }
+
+  /** {@inheritDoc} */
+  public Any add_inout_arg()
+  {
+    gnuNamedValue v = new gnuNamedValue();
+    v.setFlags(ARG_INOUT.value);
+    m_args.add(v);
+    return v.value();
+  }
+
+  /** {@inheritDoc} */
+  public Any add_named_in_arg(String name)
+  {
+    gnuNamedValue v = new gnuNamedValue();
+    v.setFlags(ARG_IN.value);
+    v.setName(name);
+    m_args.add(v);
+    return v.value();
+  }
+
+  /** {@inheritDoc} */
+  public Any add_named_inout_arg(String name)
+  {
+    gnuNamedValue v = new gnuNamedValue();
+    v.setFlags(ARG_INOUT.value);
+    v.setName(name);
+    m_args.add(v);
+    return v.value();
+  }
+
+  /** {@inheritDoc} */
+  public Any add_named_out_arg(String name)
+  {
+    gnuNamedValue v = new gnuNamedValue();
+    v.setFlags(ARG_OUT.value);
+    v.setName(name);
+    m_args.add(v);
+    return v.value();
+  }
+
+  /** {@inheritDoc} */
+  public Any add_out_arg()
+  {
+    gnuNamedValue v = new gnuNamedValue();
+    v.setFlags(ARG_OUT.value);
+    m_args.add(v);
+    return v.value();
+  }
+
+  /** {@inheritDoc} */
+  public NVList arguments()
+  {
+    return m_args;
+  }
+
+  /** {@inheritDoc} */
+  public ContextList contexts()
+  {
+    return m_context_list;
+  }
+
+  /** {@inheritDoc} */
+  public Context ctx()
+  {
+    return m_context;
+  }
+
+  /** {@inheritDoc} */
+  public void ctx(Context a_context)
+  {
+    m_context = a_context;
+  }
+
+  /** {@inheritDoc} */
+  public Environment env()
+  {
+    return m_environment;
+  }
+
+  /** {@inheritDoc} */
+  public ExceptionList exceptions()
+  {
+    return m_exceptions;
+  }
+
+  /** {@inheritDoc} */
+  public void get_response() throws org.omg.CORBA.WrongTransaction
+  {
+    /**
+     * The response is ready after it is received. FIXME implement context
+     * checks and any other functionality, if required.
+     */
+  }
+
+  /**
+   * Submit the request, suspending the current thread until the answer is
+   * received.
+   *
+   * This implementation requires to set the IOR property ({@link #setIOR(IOR)}
+   * before calling this method.
+   *
+   * @throws BAD_INV_ORDER, minor code 0, if the IOR has not been previously
+   * set.
+   *
+   * @throws SystemException if this exception has been thrown on remote side.
+   * The exact exception type and the minor code are the same as they have been
+   * for the exception, thrown on remoted side.
+   */
+  public synchronized void invoke() throws BAD_INV_ORDER
+  {
+    waitWhileBusy();
+    complete = false;
+    running = true;
+
+    if (ior == null)
+      throw new BAD_INV_ORDER("Set IOR property first");
+
+    try
+      {
+        Forwardings:
+        while (true)
+          {
+            try
+              {
+                p_invoke();
+                break Forwardings;
+              }
+            catch (ForwardRequest e)
+              {
+                try
+                  {
+                    ObjectImpl impl = (ObjectImpl) e.forward;
+                    SimpleDelegate delegate =
+                      (SimpleDelegate) impl._get_delegate();
+                    ior = delegate.getIor();
+                  }
+                catch (Exception ex)
+                  {
+                    BAD_PARAM bad =
+                      new BAD_PARAM("Unsupported forwarding target");
+                    bad.initCause(ex);
+                    throw bad;
+                  }
+              }
+          }
+      }
+    finally
+      {
+        running = false;
+        complete = true;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public String operation()
+  {
+    return m_operation;
+  }
+
+  /**
+   * Get the orb, related to the invocation target.
+   */
+  public ORB orb()
+  {
+    return orb;
+  }
+
+  /** {@inheritDoc} */
+  public boolean poll_response()
+  {
+    return complete && !running;
+  }
+
+  /** {@inheritDoc} */
+  public NamedValue result()
+  {
+    return m_result;
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   */
+  public Any return_value()
+  {
+    return m_result.value();
+  }
+
+  /** {@inheritDoc} */
+  public synchronized void send_deferred()
+  {
+    waitWhileBusy();
+    new Thread()
+      {
+        public void run()
+        {
+          invoke();
+        }
+      }.start();
+  }
+
+  /**
+   * Send a request and forget about it, not waiting for a response. This can be
+   * done also for methods that normally are expected to return some values.
+   *
+   * TODO It is generally recommended to reuse the threads. Reuse?
+   */
+  public void send_oneway()
+  {
+    final gnuRequest cloned = Clone();
+    cloned.oneWay = true;
+
+    new Thread()
+      {
+        public void run()
+        {
+          cloned.invoke();
+        }
+      }.start();
+  }
+
+  /**
+   * Set the argument list. This field is initialised as empty non null instance
+   * by default, so the method is only used in cases when the direct replacement
+   * is desired.
+   *
+   * @param a_args the argument list.
+   */
+  public void set_args(NVList a_args)
+  {
+    if (a_args instanceof gnuNVList)
+      m_args = (gnuNVList) a_args;
+    else
+      {
+        try
+          {
+            // In case if this is another implementation of the NVList.
+            m_args.list.clear();
+            for (int i = 0; i < a_args.count(); i++)
+              {
+                m_args.add(a_args.item(i));
+              }
+          }
+        catch (Bounds ex)
+          {
+            Unexpected.error(ex);
+          }
+      }
+  }
+
+  /**
+   * Set the context list that is later returned by the method
+   * {@link #contexts()}.
+   *
+   * @param a_context_list a new context list.
+   */
+  public void set_context_list(ContextList a_context_list)
+  {
+    m_context_list = a_context_list;
+  }
+
+  /**
+   * Set the exception container. This field is initialised as empty non null
+   * instance by default, so the method is only used in cases when the direct
+   * replacement is desired.
+   *
+   * @param a_environment the new exception container.
+   */
+  public void set_environment(Environment a_environment)
+  {
+    m_environment = a_environment;
+  }
+
+  /**
+   * Set the list of exceptions. This field is initialised as empty non null
+   * instance by default, so the method is only used in cases when the direct
+   * replacement is desired.
+   *
+   * @param a_exceptions a list of exceptions.
+   */
+  public void set_exceptions(ExceptionList a_exceptions)
+  {
+    m_exceptions = a_exceptions;
+  }
+
+  /**
+   * Set the operation name.
+   *
+   * @param a_operation the operation name.
+   */
+  public void set_operation(String a_operation)
+  {
+    m_operation = a_operation;
+  }
+
+  /**
+   * Set the named value, returned as result. This field is initialised as empty
+   * non null instance by default, so the method is only used in cases when the
+   * direct replacement is desired.
+   *
+   * @param a_result the result keeper.
+   */
+  public void set_result(NamedValue a_result)
+  {
+    m_result = a_result;
+  }
+
+  /**
+   * Set the type of the named value, returned as a result. Instantiates a new
+   * instance of the result value.
+   */
+  public void set_return_type(TypeCode returns)
+  {
+    if (m_result == null || !returns.equal(m_result.value().type()))
+      {
+        m_result = new gnuNamedValue();
+        m_result.value().type(returns);
+      }
+  }
+
+  /**
+   * Set the invocation target.
+   *
+   * @param a_target the CORBA object for that the method will be invoked.
+   */
+  public void set_target(org.omg.CORBA.Object a_target)
+  {
+    m_target = a_target;
+  }
+
+  /**
+   * Do the actual invocation. This implementation requires to set the IOR
+   * property ({@link #setIOR(IOR)} before calling this method.
+   *
+   * @throws BAD_INV_ORDER, minor code 0, if the IOR has not been previously set
+   *           or if the direct argument addition is mixed with the direct
+   *           argument writing into the output stream.
+   * @return the server response in binary form.
+   */
+public synchronized RawReply submit()
+    throws ForwardRequest
+  {
+    gnu.CORBA.GIOP.MessageHeader header = new gnu.CORBA.GIOP.MessageHeader();
+
+    header.setBigEndian(Big_endian);
+
+    // The byte order will be Big Endian by default.
+    header.message_type = gnu.CORBA.GIOP.MessageHeader.REQUEST;
+    header.version = useVersion(ior.Internet.version);
+
+    RequestHeader rh = header.create_request_header();
+    rh.operation = m_operation;
+    rh.object_key = ior.key;
+
+    // Update interceptor.
+    m_rqh = rh;
+
+    if (m_interceptor != null)
+      m_interceptor.send_request(m_info);
+
+    // Prepare the submission.
+    BufferedCdrOutput request_part = new BufferedCdrOutput();
+
+    request_part.setOffset(header.getHeaderSize());
+    request_part.setVersion(header.version);
+    request_part.setCodeSet(CodeSetServiceContext.negotiate(ior.Internet.CodeSets));
+    request_part.setOrb(orb);
+    request_part.setBigEndian(header.isBigEndian());
+
+    // This also sets the stream encoding to the encoding, specified
+    // in the header.
+    rh.write(request_part);
+
+    if (m_args != null && m_args.count() > 0)
+      {
+        write_parameters(header, request_part);
+
+        if (m_parameter_buffer != null)
+          throw new BAD_INV_ORDER("Please either add parameters or "
+            + "write them into stream, but not both " + "at once.");
+      }
+
+    if (m_parameter_buffer != null)
+      {
+        write_parameter_buffer(header, request_part);
+      }
+
+    // Now the message size is available.
+    header.message_size = request_part.buffer.size();
+
+    Socket socket = null;
+
+    java.lang.Object key = ior.Internet.host + ":" + ior.Internet.port;
+
+    synchronized (SocketRepository.class)
+      {
+        socket = SocketRepository.get_socket(key);
+      }
+
+    try
+      {
+        long pause = PAUSE_INITIAL;
+
+        if (socket == null)
+          {
+            // The IOException may be thrown under very heavy parallel
+            // load. For some time, just wait, exceptiong the socket to free.
+            Open: for (int i = 0; i < PAUSE_STEPS; i++)
+              {
+                try
+                  {
+                    if (orb instanceof OrbFunctional)
+                      socket = ((OrbFunctional) orb).socketFactory.
+                        createClientSocket(
+                          ior.Internet.host, ior.Internet.port);
+                    else
+                      socket = new Socket(ior.Internet.host, ior.Internet.port);
+                    break Open;
+                  }
+                catch (IOException ex)
+                  {
+                    try
+                      {
+                        // Expecting to free a socket via finaliser.
+                        System.gc();
+                        Thread.sleep(pause);
+                        pause = pause * 2;
+                        if (pause > PAUSE_MAX)
+                          pause = PAUSE_MAX;
+                      }
+                    catch (InterruptedException iex)
+                      {
+                      }
+                  }
+              }
+          }
+
+        if (socket == null)
+          throw new NO_RESOURCES(ior.Internet.host + ":" + ior.Internet.port
+            + " in use");
+        socket.setKeepAlive(true);
+
+        OutputStream socketOutput = socket.getOutputStream();
+
+        // Write the message header.
+        header.write(socketOutput);
+
+        // Write the request header and parameters (if present).
+        request_part.buffer.writeTo(socketOutput);
+
+        socketOutput.flush();
+        if (!socket.isClosed() && !oneWay)
+          {
+            MessageHeader response_header = new MessageHeader();
+            InputStream socketInput = socket.getInputStream();
+            response_header.read(socketInput);
+
+            byte[] r;
+            if (orb instanceof OrbFunctional)
+              {
+                OrbFunctional fo = (OrbFunctional) orb;
+                r = response_header.readMessage(socketInput, socket,
+                  fo.TOUT_WHILE_READING, fo.TOUT_AFTER_RECEIVING);
+              }
+            else
+              r = response_header.readMessage(socketInput, null, 0, 0);
+
+            return new RawReply(orb, response_header, r);
+          }
+        else
+          return EMPTY;
+      }
+    catch (IOException io_ex)
+      {
+        COMM_FAILURE m = new COMM_FAILURE("Unable to open a socket at "
+          + ior.Internet.host + ":" + ior.Internet.port, 0xC9,
+          CompletionStatus.COMPLETED_NO);
+        m.initCause(io_ex);
+        throw m;
+      }
+    finally
+      {
+        try
+          {
+            if (socket != null && !socket.isClosed())
+              {
+                socket.setSoTimeout(OrbFunctional.TANDEM_REQUESTS);
+                SocketRepository.put_socket(key, socket);
+              }
+          }
+        catch (IOException scx)
+          {
+            InternalError ierr = new InternalError();
+            ierr.initCause(scx);
+            throw ierr;
+          }
+      }
+  }
+
+  /** {@inheritDoc} */
+  public org.omg.CORBA.Object target()
+  {
+    return m_target;
+  }
+
+  /**
+   * Get the used version. Normally, it is better to respond using the same
+   * version as it is specified in IOR, but not above the maximal supported
+   * version.
+   */
+  public Version useVersion(Version desired)
+  {
+    if (desired.until_inclusive(MAX_SUPPORTED.major, MAX_SUPPORTED.minor))
+      return desired;
+    else
+      return MAX_SUPPORTED;
+  }
+
+  /**
+   * Wait while the response to request, submitted using
+   * {@link #send_deferred()} or {@link #invoke()} (from other thread) is
+   * returned.
+   *
+   * FIXME It is possible to rewrite this using Object.wait() and
+   * Object.notify(), but be sure to prepare the test as well.
+   */
+  public synchronized void waitWhileBusy()
+  {
+    // Waiting constants.
+    long wait = 10;
+    long increment = 2;
+    long max = 5000;
+
+    while (running)
+      {
+        try
+          {
+            Thread.sleep(wait);
+            if (wait < max)
+              wait = wait * increment;
+          }
+        catch (InterruptedException ex)
+          {
+          }
+      }
+  }
+
+  /**
+   * Do actual invocation. This method recursively calls itself if the
+   * redirection is detected.
+   */
+  private void p_invoke()
+    throws SystemException, ForwardRequest
+  {
+    RawReply response = submit();
+
+    // If this is a one way message, do not care about the response.
+    if (oneWay && response == EMPTY)
+      return;
+
+    if (m_rph == null)
+      m_rph = response.header.create_reply_header();
+
+    BufferredCdrInput input = response.getStream();
+    input.setOrb(orb);
+
+    m_rph.read(input);
+
+    // The stream must be aligned sinve v1.2, but only once.
+    boolean align = response.header.version.since_inclusive(1, 2);
+
+    switch (m_rph.reply_status)
+      {
+        case ReplyHeader.NO_EXCEPTION:
+
+          NamedValue arg;
+
+          // Read return value, if set.
+          if (m_result != null)
+            {
+              if (align)
+                {
+                  input.align(8);
+                  align = false;
+                }
+              m_result.value().read_value(input, m_result.value().type());
+            }
+
+          // Read returned parameters, if set.
+          if (m_args != null)
+            for (int i = 0; i < m_args.count(); i++)
+              {
+                try
+                  {
+                    arg = m_args.item(i);
+
+                    // Both ARG_INOUT and ARG_OUT have this binary flag set.
+                    if ((arg.flags() & ARG_OUT.value) != 0)
+                      {
+                        if (align)
+                          {
+                            input.align(8);
+                            align = false;
+                          }
+
+                        arg.value().read_value(input, arg.value().type());
+                      }
+                  }
+                catch (Bounds ex)
+                  {
+                    Unexpected.error(ex);
+                  }
+              }
+
+          if (m_interceptor != null)
+            m_interceptor.receive_reply(m_info);
+
+          break;
+
+        case ReplyHeader.SYSTEM_EXCEPTION:
+          if (align)
+            {
+              input.align(8);
+              align = false;
+            }
+          readExceptionId(input);
+
+          m_sys_ex = ObjectCreator.readSystemException(input,
+            m_rph.service_context);
+          m_environment.exception(m_sys_ex);
+
+          if (m_interceptor != null)
+            m_interceptor.receive_exception(m_info);
+
+          throw m_sys_ex;
+
+        case ReplyHeader.USER_EXCEPTION:
+          if (align)
+            {
+              input.align(8);
+              align = false;
+            }
+          readExceptionId(input);
+
+          // Prepare an Any that will hold the exception.
+          gnuAny exc = new gnuAny();
+          exc.setOrb(orb);
+
+          exc.insert_Streamable(new StreamHolder(input));
+
+          UnknownUserException unuex = new UnknownUserException(exc);
+          m_environment.exception(unuex);
+
+          if (m_interceptor != null)
+            m_interceptor.receive_exception(m_info);
+
+          break;
+
+        case ReplyHeader.LOCATION_FORWARD_PERM:
+        case ReplyHeader.LOCATION_FORWARD:
+          if (response.header.version.since_inclusive(1, 2))
+            input.align(8);
+
+          IOR forwarded = new IOR();
+          try
+            {
+              forwarded._read_no_endian(input);
+            }
+          catch (IOException ex)
+            {
+              new MARSHAL("Cant read forwarding info", 5103,
+                CompletionStatus.COMPLETED_NO);
+            }
+
+          setIor(forwarded);
+
+          m_forward_ior = forwarded;
+
+          if (m_interceptor != null)
+            m_interceptor.receive_other(m_info);
+
+          // Repeat with the forwarded information.
+          p_invoke();
+          return;
+
+        default:
+          throw new MARSHAL("Unknow reply status", 8100 + m_rph.reply_status,
+            CompletionStatus.COMPLETED_NO);
+      }
+  }
+
+  /**
+   * Read exception id without changing the stream pointer position.
+   */
+  void readExceptionId(BufferredCdrInput input)
+  {
+    input.mark(2048);
+    m_exception_id = input.read_string();
+    input.reset();
+  }
+
+  /**
+   * Write the operation parameters.
+   *
+   * @param header the message header
+   * @param request_part the stream to write parameters into
+   *
+   * @throws MARSHAL if the attempt to write the parameters has failde.
+   */
+  protected void write_parameter_buffer(MessageHeader header,
+    BufferedCdrOutput request_part
+  ) throws MARSHAL
+  {
+    try
+      {
+        if (header.version.since_inclusive(1, 2))
+          {
+            request_part.align(8);
+          }
+        m_parameter_buffer.buffer.writeTo(request_part);
+      }
+    catch (IOException ex)
+      {
+        MARSHAL m = new MARSHAL("Unable to write method arguments to CDR output.");
+        m.minor = Minor.CDR;
+        throw m;
+      }
+  }
+
+  /**
+   * Write the operation parameters.
+   *
+   * @param header the message header
+   * @param request_part the stream to write parameters into
+   *
+   * @throws MARSHAL if the attempt to write the parameters has failde.
+   */
+  protected void write_parameters(MessageHeader header,
+    BufferedCdrOutput request_part
+  ) throws MARSHAL
+  {
+    // Align after 1.2, but only once.
+    boolean align = header.version.since_inclusive(1, 2);
+    NamedValue para;
+
+    try
+      {
+        // Write parameters now.
+        for (int i = 0; i < m_args.count(); i++)
+          {
+            para = m_args.item(i);
+
+            // This bit is set both for ARG_IN and ARG_INOUT
+            if ((para.flags() & ARG_IN.value) != 0)
+              {
+                if (align)
+                  {
+                    request_part.align(8);
+                    align = false;
+                  }
+                para.value().write_value(request_part);
+              }
+          }
+      }
+    catch (Bounds ex)
+      {
+        InternalError ierr = new InternalError();
+        ierr.initCause(ex);
+        throw ierr;
+      }
+  }
+
+  /* **************Implementation of the request info operations. ***** */
+
+  /**
+   * Add context to request.
+   */
+  public void add_request_service_context(ServiceContext service_context,
+    boolean replace
+  )
+  {
+    m_rqh.addContext(service_context, replace);
+  }
+
+  /**
+   * Get the Internet profile as an effective profile.
+   */
+  public TaggedProfile effective_profile()
+  {
+    BufferedCdrOutput buf = new BufferedCdrOutput(512);
+    buf.setOrb(orb);
+    ior.Internet.write(buf);
+
+    TaggedProfile p = new TaggedProfile();
+    p.tag = TAG_INTERNET_IOP.value;
+    p.profile_data = buf.buffer.toByteArray();
+    return p;
+  }
+
+  /**
+   * Return either target or forwarded targed.
+   */
+  public org.omg.CORBA.Object effective_target()
+  {
+    return new IorObject(orb, ior);
+  }
+
+  /**
+   * Get effective component with the give id from the Internet profile.
+   */
+  public TaggedComponent get_effective_component(int id)
+    throws BAD_PARAM
+  {
+    if (id == TAG_CODE_SETS.value)
+      {
+        // Codesets are encoded separately.
+        BufferedCdrOutput buf = new BufferedCdrOutput(512);
+        buf.setOrb(orb);
+        ior.Internet.CodeSets.write(buf);
+
+        TaggedComponent t = new TaggedComponent();
+        t.tag = TAG_CODE_SETS.value;
+        t.component_data = buf.buffer.toByteArray();
+        return t;
+      }
+    else
+      {
+        for (int i = 0; i < ior.Internet.components.size(); i++)
+          {
+            TaggedComponent c =
+              (TaggedComponent) ior.Internet.components.get(i);
+            if (c.tag == id)
+              return c;
+          }
+      }
+    throw new BAD_PARAM("No component " + id + " in the Internet profile", 28,
+      CompletionStatus.COMPLETED_MAYBE
+    );
+  }
+
+  /**
+   * Get all components with the given id from the internet profile.
+   */
+  public TaggedComponent[] get_effective_components(int id)
+    throws BAD_PARAM
+  {
+    if (id == TAG_CODE_SETS.value)
+      return new TaggedComponent[] { get_effective_component(TAG_CODE_SETS.value) };
+    else
+      {
+        ArrayList components = new ArrayList(ior.Internet.components.size());
+        for (int i = 0; i < ior.Internet.components.size(); i++)
+          {
+            TaggedComponent c =
+              (TaggedComponent) ior.Internet.components.get(i);
+            if (c.tag == id)
+              components.add(c);
+          }
+        if (components.size() == 0)
+          throw new BAD_PARAM("No component " + id +
+            " in the Internet profile", 28, CompletionStatus.COMPLETED_MAYBE
+          );
+        else
+          {
+            TaggedComponent[] t = new TaggedComponent[ components.size() ];
+            for (int i = 0; i < t.length; i++)
+              t [ i ] = (TaggedComponent) components.get(i);
+            return t;
+          }
+      }
+  }
+
+  /**
+   * This should be not implemented up till jdk 1.5 inclusive.
+   */
+  public Policy get_request_policy(int type) throws INV_POLICY
+  {
+    throw new NO_IMPLEMENT();
+  }
+
+  /** @inheritDoc */
+  public String received_exception_id()
+  {
+    return m_exception_id;
+  }
+
+  /** @inheritDoc */
+  public Any received_exception()
+  {
+    if (m_exception_id == null)
+      return null;
+
+    if (m_sys_ex != null)
+      {
+        Any a = orb.create_any();
+        ObjectCreator.insertSysException(a, m_sys_ex);
+        return a;
+      }
+
+    Exception mex = m_environment.exception();
+
+    UnknownUserException ex = (UnknownUserException) mex;
+    if (ex == null)
+      return null;
+    else
+      return ex.except;
+  }
+
+  /**
+   * Return the forwarded reference, null if none.
+   */
+  public org.omg.CORBA.Object forward_reference()
+  {
+    if (m_forwarding_target != null)
+      return m_forwarding_target;
+
+    if (m_forward_ior != null)
+      return new IorObject(orb, m_forward_ior);
+    else
+      return null;
+  }
+
+  /**
+   * Get the slot from the slot array inside this request.
+   */
+  public Any get_slot(int id) throws InvalidSlot
+  {
+    try
+      {
+        return m_slots [ id ];
+      }
+    catch (Exception e)
+      {
+        throw new InvalidSlot("slot id " + id + ":" + e);
+      }
+  }
+
+  /**
+   * Get the reply status.
+   */
+  public short reply_status()
+  {
+    if (m_rph == null)
+      throw new BAD_INV_ORDER("Request not yet sent", 14,
+        CompletionStatus.COMPLETED_NO
+      );
+    return (short) m_rph.reply_status;
+  }
+
+  /**
+   * Get the request id.
+   */
+  public int request_id()
+  {
+    return m_rqh.request_id;
+  }
+
+  /**
+   * Return true if the response is expected.
+   */
+  public boolean response_expected()
+  {
+    return !oneWay;
+  }
+
+  /**
+   * Determines how far the request shall progress before control is returned to
+   * the client. However up till JDK 1.5 inclusive this method always returns
+   * SYNC_WITH_TRANSPORT.
+   *
+   * @return {@link org.omg.Messaging.SYNC_WITH_TRANSPORT.value (1), always.
+   *
+   * @specnote as defined in the Suns 1.5 JDK API.
+   */
+  public short sync_scope()
+  {
+    return org.omg.Messaging.SYNC_WITH_TRANSPORT.value;
+  }
+
+  /** @inheritDoc */
+  public ServiceContext get_request_service_context(int ctx_name)
+    throws BAD_PARAM
+  {
+    return gnu.CORBA.GIOP.ServiceContext.findContext(ctx_name,
+      m_rqh.service_context
+    );
+  }
+
+  /** @inheritDoc */
+  public ServiceContext get_reply_service_context(int ctx_name)
+    throws BAD_PARAM
+  {
+    if (m_rph == null)
+      throw new BAD_INV_ORDER("Reply context not yet available");
+    return gnu.CORBA.GIOP.ServiceContext.findContext(ctx_name,
+      m_rph.service_context
+    );
+  }
+
+  /** @inheritDoc */
+  public String[] operation_context()
+  {
+    return ice_contexts();
+  }
+
+  /**
+   * Get contexts as required by interceptor.
+   */
+  public String[] ice_contexts()
+  {
+    if (m_context_list == null)
+      return new String[ 0 ];
+    else
+      {
+        try
+          {
+            String[] cn = new String[ m_context_list.count() ];
+            for (int i = 0; i < cn.length; i++)
+              cn [ i ] = m_context_list.item(i);
+            return cn;
+          }
+        catch (Bounds e)
+          {
+            throw new Unexpected(e);
+          }
+      }
+  }
+
+  /**
+   * Check if the call is done via DII.
+   */
+  public void checkDii()
+  {
+    if (m_parameter_buffer != null)
+      throw new NO_RESOURCES("The invocation method provides " +
+        "no access to this resource. DII call required.", 1,
+        CompletionStatus.COMPLETED_MAYBE
+      );
+  }
+}