/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
package com.sun.star.lib.uno.protocols.urp;
import com.sun.star.bridge.InvalidProtocolChangeException;
import com.sun.star.bridge.ProtocolProperty;
import com.sun.star.bridge.XProtocolProperties;
import com.sun.star.lang.DisposedException;
import com.sun.star.lib.uno.environments.remote.IProtocol;
import com.sun.star.lib.uno.environments.remote.Message;
import com.sun.star.lib.uno.environments.remote.ThreadId;
import com.sun.star.lib.uno.typedesc.MethodDescription;
import com.sun.star.lib.uno.typedesc.TypeDescription;
import com.sun.star.uno.Any;
import com.sun.star.uno.IBridge;
import com.sun.star.uno.IMethodDescription;
import com.sun.star.uno.ITypeDescription;
import com.sun.star.uno.Type;
import com.sun.star.uno.TypeClass;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XCurrentContext;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Random;
import java.util.StringTokenizer;
// This class internally relies on the availability of Java UNO type information
// for the interface type com.sun.star.bridge.XProtocolProperties, even though
// URP itself does not rely on that type.
public final class urp implements IProtocol {
public urp(
IBridge bridge, String attributes, InputStream input,
OutputStream output)
{
this.input = new DataInputStream(input);
this.output = new DataOutputStream(output);
marshal = new Marshal(bridge, CACHE_SIZE);
unmarshal = new Unmarshal(bridge, CACHE_SIZE);
forceSynchronous = parseAttributes(attributes);
}
// @see IProtocol#init
public void init() throws IOException {
synchronized (monitor) {
if (state == STATE_INITIAL0) {
sendRequestChange();
}
}
}
// @see IProtocol#terminate
public void terminate() {
synchronized (monitor) {
state = STATE_TERMINATED;
initialized = true;
monitor.notifyAll();
}
}
// @see IProtocol#readMessage
public Message readMessage() throws IOException {
for (;;) {
if (!unmarshal.hasMore()) {
unmarshal.reset(readBlock());
if (!unmarshal.hasMore()) {
throw new IOException("closeConnection message received");
}
}
UrpMessage msg;
int header = unmarshal.read8Bit();
if ((header & HEADER_LONGHEADER) != 0) {
if ((header & HEADER_REQUEST) != 0) {
msg = readLongRequest(header);
} else {
msg = readReply(header);
}
} else {
msg = readShortRequest(header);
}
if (msg.isInternal()) {
handleInternalMessage(msg);
} else {
return msg;
}
}
}
// @see IProtocol#writeRequest
public boolean writeRequest(
String oid, TypeDescription type, String function, ThreadId tid,
Object[] arguments)
throws IOException
{
if (oid.equals(PROPERTIES_OID)) {
throw new IllegalArgumentException("illegal OID " + oid);
}
synchronized (monitor) {
while (!initialized) {
try {
monitor.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e.toString());
}
}
if (state == STATE_TERMINATED) {
throw new DisposedException();
}
return writeRequest(false, oid, type, function, tid, arguments);
}
}
// @see IProtocol#writeReply
public void writeReply(boolean exception, ThreadId tid, Object result)
throws IOException
{
synchronized (output) {
writeQueuedReleases();
int header = HEADER_LONGHEADER;
PendingRequests.Item pending = pendingIn.pop(tid);
TypeDescription resultType;
ITypeDescription[] argTypes;
Object[] args;
if (exception) {
header |= HEADER_EXCEPTION;
resultType = TypeDescription.getTypeDescription(TypeClass.ANY);
argTypes = null;
args = null;
} else {
resultType = (TypeDescription)
pending.function.getReturnSignature();
argTypes = pending.function.getOutSignature();
args = pending.arguments;
}
if (!tid.equals(outL1Tid)) {
header |= HEADER_NEWTID;
outL1Tid = tid;
} else {
tid = null;
}
marshal.write8Bit(header);
if (tid != null) {
marshal.writeThreadId(tid);
}
marshal.writeValue(resultType, result);
if (argTypes != null) {
for (int i = 0; i < argTypes.length; ++i) {
if (argTypes[i] != null) {
marshal.writeValue(
(TypeDescription) argTypes[i].getComponentType(),
Array.get(args[i], 0));
}
}
}
writeBlock(true);
}
}
private void sendRequestChange() throws IOException {
if (propertiesTid == null) {
propertiesTid = ThreadId.createFresh();
}
random = new Random().nextInt();
writeRequest(
true, PROPERTIES_OID,
TypeDescription.getTypeDescription(XProtocolProperties.class),
PROPERTIES_FUN_REQUEST_CHANGE, propertiesTid,
new Object[] { new Integer(random) });
state = STATE_REQUESTED;
}
private void handleInternalMessage(Message message) throws IOException {
if (message.isRequest()) {
String t = message.getType().getTypeName();
if (!t.equals("com.sun.star.bridge.XProtocolProperties")) {
throw new IOException(
"read URP protocol properties request with unsupported"
+ " type " + t);
}
int fid = message.getMethod().getIndex();
switch (fid) {
case PROPERTIES_FID_REQUEST_CHANGE:
checkSynchronousPropertyRequest(message);
synchronized (monitor) {
switch (state) {
case STATE_INITIAL0:
case STATE_INITIAL:
writeReply(
false, message.getThreadId(), new Integer(1));
state = STATE_WAIT;
break;
case STATE_REQUESTED:
int n
= ((Integer) message.getArguments()[0]).intValue();
if (random < n) {
writeReply(
false, message.getThreadId(), new Integer(1));
state = STATE_WAIT;
} else if (random == n) {
writeReply(
false, message.getThreadId(), new Integer(-1));
state = STATE_INITIAL;
sendRequestChange();
} else {
writeReply(
false, message.getThreadId(), new Integer(0));
}
break;
default:
writeReply(
true, message.getThreadId(),
new com.sun.star.uno.RuntimeException(
"read URP protocol properties requestChange"
+ " request in illegal state"));
break;
}
}
break;
case PROPERTIES_FID_COMMIT_CHANGE:
checkSynchronousPropertyRequest(message);
synchronized (monitor) {
if (state == STATE_WAIT) {
ProtocolProperty[] p = (ProtocolProperty[])
message.getArguments()[0];
boolean ok = true;
boolean cc = false;
int i = 0;
for (; i < p.length; ++i) {
if (p[i].Name.equals(PROPERTY_CURRENT_CONTEXT)) {
cc = true;
} else {
ok = false;
break;
}
}
if (ok) {
writeReply(false, message.getThreadId(), null);
} else {
writeReply(
true, message.getThreadId(),
new InvalidProtocolChangeException(
"", null, p[i], 1));
}
state = STATE_INITIAL;
if (!initialized) {
if (cc) {
currentContext = true;
initialized = true;
monitor.notifyAll();
} else {
sendRequestChange();
}
}
} else {
writeReply(
true, message.getThreadId(),
new com.sun.star.uno.RuntimeException(
"read URP protocol properties commitChange"
+ " request in illegal state"));
}
}
break;
default:
throw new IOException(
"read URP protocol properties request with unsupported"
+ " function ID " + fid);
}
} else {
synchronized (monitor) {
if (state == STATE_COMMITTED) {
// commitChange reply:
if (!message.isAbnormalTermination()) {
currentContext = true;
}
state = STATE_INITIAL;
initialized = true;
monitor.notifyAll();
} else {
// requestChange reply:
if (message.isAbnormalTermination()) {
// remote side probably does not support negotiation:
state = STATE_INITIAL;
initialized = true;
monitor.notifyAll();
} else {
int n = ((Integer) message.getResult()).intValue();
switch (n) {
case -1:
case 0:
break;
case 1:
writeRequest(
true, PROPERTIES_OID,
TypeDescription.getTypeDescription(
XProtocolProperties.class),
PROPERTIES_FUN_COMMIT_CHANGE, propertiesTid,
new Object[] {
new ProtocolProperty[] {
new ProtocolProperty(
PROPERTY_CURRENT_CONTEXT,
Any.VOID) } });
state = STATE_COMMITTED;
break;
default:
throw new IOException(
"read URP protocol properties "
+ PROPERTIES_FUN_REQUEST_CHANGE
+ " reply with illegal return value " + n);
}
}
}
}
}
}
private void checkSynchronousPropertyRequest(Message message)
throws IOException
{
if (!message.isSynchronous()) {
throw new IOException(
"read URP protocol properties request for synchronous function"
+ " marked as not SYNCHRONOUS");
}
}
private byte[] readBlock() throws IOException {
int size = input.readInt();
input.readInt(); // ignore count
byte[] bytes = new byte[size];
input.readFully(bytes);
return bytes;
}
private UrpMessage readLongRequest(int header) throws IOException {
boolean sync = false;
if ((header & HEADER_MOREFLAGS) != 0) {
if (unmarshal.read8Bit() != (HEADER_MUSTREPLY | HEADER_SYNCHRONOUS))
{
throw new IOException(
"read URP request with bad MUSTREPLY/SYNCHRONOUS byte");
}
sync = true;
}
int funId = (header & HEADER_FUNCTIONID16) != 0
? unmarshal.read16Bit() : unmarshal.read8Bit();
if ((header & HEADER_NEWTYPE) != 0) {
inL1Type = unmarshal.readType();
if (inL1Type.getTypeClass() != TypeClass.INTERFACE) {
throw new IOException(
"read URP request with non-interface type " + inL1Type);
}
}
if ((header & HEADER_NEWOID) != 0) {
inL1Oid = unmarshal.readObjectId();
}
if ((header & HEADER_NEWTID) != 0) {
inL1Tid = unmarshal.readThreadId();
}
return readRequest(funId, sync);
}
private UrpMessage readShortRequest(int header) {
int funId = (header & HEADER_FUNCTIONID14) != 0
? ((header & HEADER_FUNCTIONID) << 8) | unmarshal.read8Bit()
: header & HEADER_FUNCTIONID;
return readRequest(funId, false);
}
private UrpMessage readRequest(int functionId, boolean forcedSynchronous) {
boolean internal = PROPERTIES_OID.equals(inL1Oid);
// inL1Oid may be null in XInstanceProvider.getInstance("")
XCurrentContext cc =
(currentContext && !internal
&& functionId != MethodDescription.ID_RELEASE)
? (XCurrentContext) unmarshal.readInterface(
new Type(XCurrentContext.class))
: null;
IMethodDescription desc = inL1Type.getMethodDescription(functionId);
ITypeDescription[] inSig = desc.getInSignature();
ITypeDescription[] outSig = desc.getOutSignature();
Object[] args = new Object[inSig.length];
for (int i = 0; i < args.length; ++i) {
if (inSig[i] != null) {
if (outSig[i] != null) {
Object inout = Array.newInstance(
outSig[i].getComponentType().getZClass(), 1);
Array.set(
inout, 0,
unmarshal.readValue(
(TypeDescription) outSig[i].getComponentType()));
args[i] = inout;
} else {
args[i] = unmarshal.readValue((TypeDescription) inSig[i]);
}
} else {
args[i] = Array.newInstance(
outSig[i].getComponentType().getZClass(), 1);
}
}
boolean sync = forcedSynchronous || !desc.isOneway();
if (sync) {
pendingIn.push(
inL1Tid, new PendingRequests.Item(internal, desc, args));
}
return new UrpMessage(
inL1Tid, true, inL1Oid, inL1Type, desc, sync, cc, false, null, args,
internal);
}
private UrpMessage readReply(int header) {
if ((header & HEADER_NEWTID) != 0) {
inL1Tid = unmarshal.readThreadId();
}
PendingRequests.Item pending = pendingOut.pop(inL1Tid);
TypeDescription resultType;
ITypeDescription[] argTypes;
Object[] args;
boolean exception = (header & HEADER_EXCEPTION) != 0;
if (exception) {
resultType = TypeDescription.getTypeDescription(TypeClass.ANY);
argTypes = null;
args = null;
} else {
resultType = (TypeDescription)
pending.function.getReturnSignature();
argTypes = pending.function.getOutSignature();
args = pending.arguments;
}
Object result = resultType == null
? null : unmarshal.readValue(resultType);
if (argTypes != null) {
for (int i = 0; i < argTypes.length; ++i) {
if (argTypes[i] != null) {
Array.set(
args[i], 0,
unmarshal.readValue(
(TypeDescription) argTypes[i].getComponentType()));
}
}
}
return new UrpMessage(
inL1Tid, false, null, null, null, false, null, exception, result,
args, pending.internal);
}
private boolean writeRequest(
boolean internal, String oid, TypeDescription type, String function,
ThreadId tid, Object[] arguments)
throws IOException
{
IMethodDescription desc = type.getMethodDescription(function);
synchronized (output) {
if (desc.getIndex() == MethodDescription.ID_RELEASE
&& releaseQueue.size() < MAX_RELEASE_QUEUE_SIZE)
{
releaseQueue.add(
new QueuedRelease(internal, oid, type, desc, tid));
return false;
} else {
writeQueuedReleases();
return writeRequest(
internal, oid, type, desc, tid, arguments, true);
}
}
}
private boolean writeRequest(
boolean internal, String oid, TypeDescription type,
IMethodDescription desc, ThreadId tid, Object[] arguments,
boolean flush)
throws IOException
{
int funId = desc.getIndex();
if (funId < 0 || funId > MAX_FUNCTIONID16) {
throw new IllegalArgumentException(
"function ID " + funId + " out of range");
}
boolean forceSync = forceSynchronous
&& funId != MethodDescription.ID_RELEASE;
boolean moreFlags = forceSync && desc.isOneway();
boolean longHeader = moreFlags;
int header = 0;
if (!type.equals(outL1Type)) {
longHeader = true;
header |= HEADER_NEWTYPE;
outL1Type = type;
} else {
type = null;
}
if (!oid.equals(outL1Oid)) {
longHeader = true;
header |= HEADER_NEWOID;
outL1Oid = oid;
} else {
oid = null;
}
if (!tid.equals(outL1Tid)) {
longHeader = true;
header |= HEADER_NEWTID;
outL1Tid = tid;
} else {
tid = null;
}
if (funId > MAX_FUNCTIONID14) {
longHeader = true;
}
if (longHeader) {
header |= HEADER_LONGHEADER | HEADER_REQUEST;
if (funId > MAX_FUNCTIONID8) {
header |= HEADER_FUNCTIONID16;
}
if (moreFlags) {
header |= HEADER_MOREFLAGS;
}
marshal.write8Bit(header);
if (moreFlags) {
marshal.write8Bit(HEADER_MUSTREPLY | HEADER_SYNCHRONOUS);
}
if (funId > MAX_FUNCTIONID8) {
marshal.write16Bit(funId);
} else {
marshal.write8Bit(funId);
}
if (type != null) {
marshal.writeType(type);
}
if (oid != null) {
marshal.writeObjectId(oid);
}
if (tid != null) {
marshal.writeThreadId(tid);
}
} else {
if (funId > HEADER_FUNCTIONID) {
marshal.write8Bit(HEADER_FUNCTIONID14 | (funId >> 8));
}
marshal.write8Bit(funId);
}
if (currentContext && !internal
&& funId != MethodDescription.ID_RELEASE)
{
marshal.writeInterface(
UnoRuntime.getCurrentContext(),
new Type(XCurrentContext.class));
}
ITypeDescription[] inSig = desc.getInSignature();
ITypeDescription[] outSig = desc.getOutSignature();
for (int i = 0; i < inSig.length; ++i) {
if (inSig[i] != null) {
if (outSig[i] != null) {
marshal.writeValue(
(TypeDescription) outSig[i].getComponentType(),
((Object[]) arguments[i])[0]);
} else {
marshal.writeValue(
(TypeDescription) inSig[i], arguments[i]);
}
}
}
boolean sync = forceSync || !desc.isOneway();
if (sync) {
pendingOut.push(
outL1Tid, new PendingRequests.Item(internal, desc, arguments));
}
writeBlock(flush);
return sync;
}
private void writeBlock(boolean flush) throws IOException {
byte[] data = marshal.reset();
output.writeInt(data.length);
output.writeInt(1);
output.write(data);
if (flush) {
output.flush();
}
}
private void writeQueuedReleases() throws IOException {
for (int i = releaseQueue.size(); i > 0;) {
--i;
QueuedRelease r = (QueuedRelease) releaseQueue.get(i);
writeRequest(
r.internal, r.objectId, r.type, r.method, r.threadId, null,
false);
releaseQueue.remove(i);
}
}
private static boolean parseAttributes(String attributes) {
boolean forceSynchronous = true;
if (attributes != null) {
StringTokenizer t = new StringTokenizer(attributes, ",");
while (t.hasMoreTokens()) {
String a = t.nextToken();
String v = null;
int i = a.indexOf('=');
if (i >= 0) {
v = a.substring(i + 1);
a = a.substring(0, i);
}
if (a.equalsIgnoreCase("ForceSynchronous")) {
forceSynchronous = parseBooleanAttributeValue(a, v);
} else if (a.equalsIgnoreCase("negotiate")) {
// Ignored:
parseBooleanAttributeValue(a, v);
} else {
throw new IllegalArgumentException(
"unknown protocol attribute " + a);
}
}
}
return forceSynchronous;
}
private static boolean parseBooleanAttributeValue(
String attribute, String value)
{
if (value == null) {
throw new IllegalArgumentException(
"missing value for protocol attribute " + attribute);
}
if (value.equals("0")) {
return false;
} else if (value.equals("1")) {
return true;
} else {
throw new IllegalArgumentException(
"bad value " + value + " for protocol attribute " + attribute);
}
}
private static final class QueuedRelease {
public QueuedRelease(
boolean internal, String objectId, TypeDescription type,
IMethodDescription method, ThreadId threadId)
{
this.internal = internal;
this.objectId = objectId;
this.type = type;
this.method = method;
this.threadId = threadId;
}
public final boolean internal;
public final String objectId;
public final TypeDescription type;
public final IMethodDescription method;
public final ThreadId threadId;
}
private static final String PROPERTIES_OID = "UrpProtocolProperties";
private static final int PROPERTIES_FID_REQUEST_CHANGE = 4;
private static final String PROPERTIES_FUN_REQUEST_CHANGE = "requestChange";
private static final int PROPERTIES_FID_COMMIT_CHANGE = 5;
private static final String PROPERTIES_FUN_COMMIT_CHANGE = "commitChange";
private static final String PROPERTY_CURRENT_CONTEXT = "CurrentContext";
private static final short CACHE_SIZE = 256;
private static final int HEADER_LONGHEADER = 0x80;
private static final int HEADER_REQUEST = 0x40;
private static final int HEADER_NEWTYPE = 0x20;
private static final int HEADER_NEWOID = 0x10;
private static final int HEADER_NEWTID = 0x08;
private static final int HEADER_FUNCTIONID16 = 0x04;
private static final int HEADER_MOREFLAGS = 0x01;
private static final int HEADER_MUSTREPLY = 0x80;
private static final int HEADER_SYNCHRONOUS = 0x40;
private static final int HEADER_FUNCTIONID14 = 0x40;
private static final int HEADER_FUNCTIONID = 0x3F;
private static final int HEADER_EXCEPTION = 0x20;
private static final int MAX_FUNCTIONID16 = 0xFFFF;
private static final int MAX_FUNCTIONID14 = 0x3FFF;
private static final int MAX_FUNCTIONID8 = 0xFF;
private static final int STATE_INITIAL0 = 0;
private static final int STATE_INITIAL = 1;
private static final int STATE_REQUESTED = 2;
private static final int STATE_COMMITTED = 3;
private static final int STATE_WAIT = 4;
private static final int STATE_TERMINATED = 5;
private static final int MAX_RELEASE_QUEUE_SIZE = 100;
private final DataInput input;
private final DataOutputStream output;
private final Marshal marshal;
private final Unmarshal unmarshal;
private final boolean forceSynchronous;
private final PendingRequests pendingIn = new PendingRequests();
private final PendingRequests pendingOut = new PendingRequests();
private final Object monitor = new Object();
private int state = STATE_INITIAL0;
private boolean initialized = false;
private ThreadId propertiesTid = null;
private int random;
private boolean currentContext = false;
private ThreadId inL1Tid = null;
private String inL1Oid = null;
private TypeDescription inL1Type = null;
private ThreadId outL1Tid = null;
private String outL1Oid = null;
private ITypeDescription outL1Type = null;
private final ArrayList releaseQueue = new ArrayList(); // of QueuedRelease
}