From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; 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. --- libjava/classpath/gnu/CORBA/gnuRequest.java | 1423 +++++++++++++++++++++++++++ 1 file changed, 1423 insertions(+) create mode 100644 libjava/classpath/gnu/CORBA/gnuRequest.java (limited to 'libjava/classpath/gnu/CORBA/gnuRequest.java') 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 + ); + } +} -- cgit v1.2.3